From 9a0a59d5c85c4a1d2469f43e9d2b433e156810ba Mon Sep 17 00:00:00 2001 From: Tim King Date: Wed, 15 Feb 2012 21:52:16 +0000 Subject: [PATCH] This commit merges into trunk the branch branches/arithmetic/integers2 from r2650 to r2779. - This excludes revision 2777. This revision had some strange performance implications and was delaying the merge. - This includes the new DioSolver. The DioSolver can discover conflicts, produce substitutions, and produce cuts. - The DioSolver can be disabled at command line using --disable-dio-solver. - This includes a number of changes to the arithmetic normal form. - The Integer class features a number of new number theoretic function. - This commit includes a few rather loud warning. I will do my best to take care of them today. --- src/theory/arith/arith_rewriter.cpp | 50 +- src/theory/arith/arith_utilities.h | 6 + src/theory/arith/delta_rational.h | 32 + src/theory/arith/dio_solver.cpp | 813 ++++++++++++++++-- src/theory/arith/dio_solver.h | 383 ++++++++- src/theory/arith/normal_form.cpp | 311 ++++++- src/theory/arith/normal_form.h | 436 +++++++++- src/theory/arith/partial_model.cpp | 7 + src/theory/arith/partial_model.h | 2 +- src/theory/arith/theory_arith.cpp | 523 +++++++---- src/theory/arith/theory_arith.h | 89 +- src/util/bitvector.h | 7 +- src/util/integer_cln_imp.h | 103 +++ src/util/integer_gmp_imp.h | 118 ++- src/util/rational_cln_imp.h | 12 + src/util/rational_gmp_imp.h | 12 + test/regress/regress0/Makefile.am | 3 +- test/regress/regress0/bug288b.smt | 8 + test/regress/regress0/bug288c.smt | 9 + test/regress/regress1/arith/Makefile.am | 4 +- test/regress/regress1/arith/lpsat-goal-9.smt2 | 557 ++++++++++++ .../regress1/arith/qlock-4-10-9.base.cvc.smt2 | 557 ++++++++++++ 22 files changed, 3714 insertions(+), 328 deletions(-) create mode 100644 test/regress/regress0/bug288b.smt create mode 100644 test/regress/regress0/bug288c.smt create mode 100644 test/regress/regress1/arith/lpsat-goal-9.smt2 create mode 100644 test/regress/regress1/arith/qlock-4-10-9.base.cvc.smt2 diff --git a/src/theory/arith/arith_rewriter.cpp b/src/theory/arith/arith_rewriter.cpp index 66223b479..a309b9403 100644 --- a/src/theory/arith/arith_rewriter.cpp +++ b/src/theory/arith/arith_rewriter.cpp @@ -182,37 +182,43 @@ RewriteResponse ArithRewriter::postRewriteAtomConstantRHS(TNode t){ TNode left = t[0]; TNode right = t[1]; - Comparison cmp = Comparison::mkComparison(t.getKind(), Polynomial::parsePolynomial(left), Constant(right)); + Comparison cmp = Comparison::mkNormalComparison(t.getKind(), Polynomial::parsePolynomial(left), Constant(right)); - if(cmp.isBoolean()){ - return RewriteResponse(REWRITE_DONE, cmp.getNode()); - } + Assert(cmp.isNormalForm()); + return RewriteResponse(REWRITE_DONE, cmp.getNode()); - if(cmp.getLeft().containsConstant()){ - Monomial constantHead = cmp.getLeft().getHead(); - Assert(constantHead.isConstant()); - Constant constant = constantHead.getConstant(); + // Comparison cmp = Comparison::mkComparison(t.getKind(), Polynomial::parsePolynomial(left), Constant(right)); - Constant negativeConstantHead = -constant; + // if(cmp.isBoolean()){ + // return RewriteResponse(REWRITE_DONE, cmp.getNode()); + // } - cmp = cmp.addConstant(negativeConstantHead); - } - Assert(!cmp.getLeft().containsConstant()); + // if(cmp.getLeft().containsConstant()){ + // Monomial constantHead = cmp.getLeft().getHead(); + // Assert(constantHead.isConstant()); - if(!cmp.getLeft().getHead().coefficientIsOne()){ - Monomial constantHead = cmp.getLeft().getHead(); - Assert(!constantHead.isConstant()); - Constant constant = constantHead.getConstant(); + // Constant constant = constantHead.getConstant(); - Constant inverse = Constant::mkConstant(constant.getValue().inverse()); + // Constant negativeConstantHead = -constant; - cmp = cmp.multiplyConstant(inverse); - } - Assert(cmp.getLeft().getHead().coefficientIsOne()); + // cmp = cmp.addConstant(negativeConstantHead); + // } + // Assert(!cmp.getLeft().containsConstant()); - Assert(cmp.isBoolean() || cmp.isNormalForm()); - return RewriteResponse(REWRITE_DONE, cmp.getNode()); + // if(!cmp.getLeft().getHead().coefficientIsOne()){ + // Monomial constantHead = cmp.getLeft().getHead(); + // Assert(!constantHead.isConstant()); + // Constant constant = constantHead.getConstant(); + + // Constant inverse = Constant::mkConstant(constant.getValue().inverse()); + + // cmp = cmp.multiplyConstant(inverse); + // } + // Assert(cmp.getLeft().getHead().coefficientIsOne()); + + // Assert(cmp.isBoolean() || cmp.isNormalForm()); + // return RewriteResponse(REWRITE_DONE, cmp.getNode()); } RewriteResponse ArithRewriter::postRewriteAtom(TNode atom){ diff --git a/src/theory/arith/arith_utilities.h b/src/theory/arith/arith_utilities.h index 42f4704df..0168ee043 100644 --- a/src/theory/arith/arith_utilities.h +++ b/src/theory/arith/arith_utilities.h @@ -49,11 +49,17 @@ typedef __gnu_cxx::hash_map ArithVarToNodeMap; typedef __gnu_cxx::hash_set NodeSet; typedef context::CDSet CDNodeSet; +typedef context::CDSet CDArithVarSet; + inline Node mkRationalNode(const Rational& q){ return NodeManager::currentNM()->mkConst(q); } +inline Node mkIntegerNode(const Integer& z){ + return NodeManager::currentNM()->mkConst(z); +} + inline Node mkBoolNode(bool b){ return NodeManager::currentNM()->mkConst(b); } diff --git a/src/theory/arith/delta_rational.h b/src/theory/arith/delta_rational.h index fdc3bee3b..682d13720 100644 --- a/src/theory/arith/delta_rational.h +++ b/src/theory/arith/delta_rational.h @@ -118,6 +118,38 @@ public: return *(this); } + bool isIntegral() const { + if(getInfinitesimalPart().sgn() == 0){ + return getNoninfinitesimalPart().isIntegral(); + }else{ + return false; + } + } + + Integer floor() const { + if(getNoninfinitesimalPart().isIntegral()){ + if(getInfinitesimalPart().sgn() >= 0){ + return getNoninfinitesimalPart().getNumerator(); + }else{ + return getNoninfinitesimalPart().getNumerator() - Integer(1); + } + }else{ + return getNoninfinitesimalPart().floor(); + } + } + + Integer ceiling() const { + if(getNoninfinitesimalPart().isIntegral()){ + if(getInfinitesimalPart().sgn() <= 0){ + return getNoninfinitesimalPart().getNumerator(); + }else{ + return getNoninfinitesimalPart().getNumerator() + Integer(1); + } + }else{ + return getNoninfinitesimalPart().ceiling(); + } + } + std::string toString() const; }; diff --git a/src/theory/arith/dio_solver.cpp b/src/theory/arith/dio_solver.cpp index 151859f21..dead34807 100644 --- a/src/theory/arith/dio_solver.cpp +++ b/src/theory/arith/dio_solver.cpp @@ -26,91 +26,766 @@ namespace CVC4 { namespace theory { namespace arith { -/* -static void printEquation(vector& coeffs, - vector& variables, - ostream& out) { - Assert(coeffs.size() == variables.size()); - vector::const_iterator i = coeffs.begin(); - vector::const_iterator j = variables.begin(); - while(i != coeffs.end()) { - out << *i << "*" << *j; - ++i; - ++j; - if(i != coeffs.end()) { - out << " + "; +inline Node makeIntegerVariable(){ + NodeManager* curr = NodeManager::currentNM(); + return curr->mkVar(curr->integerType()); +} + +DioSolver::DioSolver(context::Context* ctxt) : + d_lastUsedVariable(ctxt,0), + d_inputConstraints(ctxt), + d_nextInputConstraintToEnqueue(ctxt, 0), + d_trail(ctxt), + d_subs(ctxt), + d_currentF(), + d_savedQueue(ctxt), + d_savedQueueIndex(ctxt, 0), + d_conflictHasBeenRaised(ctxt, false), + d_maxInputCoefficientLength(ctxt, 0), + d_usedDecomposeIndex(ctxt, false), + d_lastPureSubstitution(ctxt, 0), + d_pureSubstitionIter(ctxt, 0) +{} + +DioSolver::Statistics::Statistics() : + d_conflictCalls("theory::arith::dio::conflictCalls",0), + d_cutCalls("theory::arith::dio::cutCalls",0), + d_cuts("theory::arith::dio::cuts",0), + d_conflicts("theory::arith::dio::conflicts",0), + d_conflictTimer("theory::arith::dio::conflictTimer"), + d_cutTimer("theory::arith::dio::cutTimer") +{ + StatisticsRegistry::registerStat(&d_conflictCalls); + StatisticsRegistry::registerStat(&d_cutCalls); + + StatisticsRegistry::registerStat(&d_cuts); + StatisticsRegistry::registerStat(&d_conflicts); + + StatisticsRegistry::registerStat(&d_conflictTimer); + StatisticsRegistry::registerStat(&d_cutTimer); +} + +DioSolver::Statistics::~Statistics(){ + StatisticsRegistry::unregisterStat(&d_conflictCalls); + StatisticsRegistry::unregisterStat(&d_cutCalls); + + StatisticsRegistry::unregisterStat(&d_cuts); + StatisticsRegistry::unregisterStat(&d_conflicts); + + StatisticsRegistry::unregisterStat(&d_conflictTimer); + StatisticsRegistry::unregisterStat(&d_cutTimer); +} + +size_t DioSolver::allocateVariableInPool() { + Assert(d_lastUsedVariable <= d_variablePool.size()); + if(d_lastUsedVariable == d_variablePool.size()){ + Assert(d_lastUsedVariable == d_variablePool.size()); + Node intVar = makeIntegerVariable(); + d_variablePool.push_back(Variable(intVar)); + } + size_t res = d_lastUsedVariable; + d_lastUsedVariable = d_lastUsedVariable + 1; + return res; +} + + + Node DioSolver::nextPureSubstitution(){ + Assert(hasMorePureSubstitutions()); + SubIndex curr = d_pureSubstitionIter; + d_pureSubstitionIter = d_pureSubstitionIter + 1; + + Assert(d_subs[curr].d_fresh.isNull()); + Variable v = d_subs[curr].d_eliminated; + + SumPair sp = d_trail[d_subs[curr].d_constraint].d_eq; + Polynomial p = sp.getPolynomial(); + Constant c = -sp.getConstant(); + Polynomial cancelV = p + Polynomial::mkPolynomial(v); + Node eq = NodeManager::currentNM()->mkNode(kind::EQUAL, v.getNode(), cancelV.getNode()); + return eq; + } + + +bool DioSolver::debugEqualityInInputEquations(Node eq){ + typedef context::CDList::const_iterator const_iterator; + const_iterator i=d_inputConstraints.begin(), end = d_inputConstraints.end(); + for(; i != end; ++i){ + Node reason_i = (*i).d_reason; + if(eq == reason_i){ + return true; } } - out << " = 0"; + return false; } -*/ -bool DioSolver::solve() { - Trace("integers") << "DioSolver::solve()" << endl; - if(Debug.isOn("integers")) { - ScopedDebug dtab("tableau"); - d_tableau.printTableau(); +bool DioSolver::acceptableOriginalNodes(Node n){ + Kind k = n.getKind(); + if(k == kind::EQUAL){ + return true; + }else if(k == kind::AND){ + Node ub = n[0]; + Node lb = n[1]; + Kind kub = simplifiedKind(ub); + Kind klb = simplifiedKind(lb); + return (kub == kind::LEQ || kub==kind::LT) && (klb == kind::GEQ || klb == kind::GT); + }else{ + return false; } - for(ArithVarSet::const_iterator i = d_tableau.beginBasic(); - i != d_tableau.endBasic(); - ++i) { - Debug("integers") << "going through row " << *i << endl; +} + +void DioSolver::pushInputConstraint(const Comparison& eq, Node reason){ + Assert(!debugEqualityInInputEquations(reason)); + Assert(eq.isIntegral()); + Assert(eq.getNode().getKind() == kind::EQUAL); + Assert(acceptableOriginalNodes(reason)); + + SumPair sp = SumPair::comparisonToSumPair(eq); + uint32_t length = sp.maxLength(); + if(length > d_maxInputCoefficientLength){ + d_maxInputCoefficientLength = length; + } + + size_t varIndex = allocateVariableInPool(); + Variable proofVariable(d_variablePool[varIndex]); + + TrailIndex posInTrail = d_trail.size(); + d_trail.push_back(Constraint(sp,Polynomial(Monomial(VarList(proofVariable))))); + + size_t posInConstraintList = d_inputConstraints.size(); + d_inputConstraints.push_back(InputConstraint(reason, posInTrail)); - Integer m = 1; - for(Tableau::RowIterator j = d_tableau.rowIterator(*i); !j.atEnd(); ++j) { - Debug("integers") << " column " << (*j).getCoefficient() << " * " << (*j).getColVar() << endl; - m *= (*j).getCoefficient().getDenominator(); + d_varToInputConstraintMap[proofVariable.getNode()] = posInConstraintList; +} + + +DioSolver::TrailIndex DioSolver::scaleEqAtIndex(DioSolver::TrailIndex i, const Integer& g){ + Assert(g != 0); + Constant invg = Constant::mkConstant(Rational(Integer(1),g)); + const SumPair& sp = d_trail[i].d_eq; + const Polynomial& proof = d_trail[i].d_proof; + + SumPair newSP = sp * invg; + Polynomial newProof = proof * invg; + + Assert(newSP.isIntegral()); + Assert(newSP.gcd() == 1); + + TrailIndex j = d_trail.size(); + + d_trail.push_back(Constraint(newSP, newProof)); + + Debug("arith::dio") << "scaleEqAtIndex(" << i <<","< nb(kind::AND); + for(Polynomial::iterator iter = proof.begin(), end = proof.end(); iter!= end; ++iter){ + Monomial m = (*iter); + Assert(!m.isConstant()); + VarList vl = m.getVarList(); + Assert(vl.singleton()); + Variable v = vl.getHead(); + + Node input = proofVariableToReason(v); + Assert(acceptableOriginalNodes(input)); + if(input.getKind() == kind::AND){ + nb << input[0] << input[1]; + }else{ + nb << input; } - Assert(m >= 1); - Debug("integers") << "final multiplier is " << m << endl; - - Integer gcd = 0; - Rational c = 0; - Debug("integers") << "going throw row " << *i << " to find gcd" << endl; - for(Tableau::RowIterator j = d_tableau.rowIterator(*i); !j.atEnd(); ++j) { - Rational r = (*j).getCoefficient(); - ArithVar v = (*j).getColVar(); - r *= m; - Debug("integers") << " column " << r << " * " << v << endl; - Assert(r.getDenominator() == 1); - bool foundConstant = false; - // The tableau doesn't store constants. Constants int he input - // are mapped to slack variables that are constrained with - // bounds in the partial model. So we detect and accumulate all - // variables whose upper bound equals their lower bound, which - // catches these input constants as well as any (contextually) - // eliminated variables. - if(d_partialModel.hasUpperBound(v) && d_partialModel.hasLowerBound(v)) { - DeltaRational b = d_partialModel.getLowerBound(v); - if(b.getInfinitesimalPart() == 0 && b == d_partialModel.getUpperBound(v)) { - r *= b.getNoninfinitesimalPart(); - Debug("integers") << " var " << v << " == [" << b << "], so found a constant part " << r << endl; - c += r; - foundConstant = true; + } + + Node result = (nb.getNumChildren() == 1) ? nb[0] : (Node)nb; + Debug("arith::dio") << "Proof at " << i << " is " + << d_trail[i].d_eq.getNode() << endl + << d_trail[i].d_proof.getNode() << endl + << " which becomes " << result << endl; + return result; +} + +bool DioSolver::anyCoefficientExceedsMaximum(TrailIndex j) const{ + uint32_t length = d_trail[j].d_eq.maxLength(); + uint32_t nmonos = d_trail[j].d_eq.getPolynomial().numMonomials(); + + bool result = + nmonos >= 2 && + length > d_maxInputCoefficientLength + MAX_GROWTH_RATE; + if(Debug.isOn("arith::dio::max") && result){ + Debug("arith::dio::max") << "about to drop:"; + debugPrintTrail(j); + } + return result; +} + +void DioSolver::enqueueInputConstraints(){ + Assert(d_currentF.empty()); + while(d_savedQueueIndex < d_savedQueue.size()){ + d_currentF.push_back(d_savedQueue[d_savedQueueIndex]); + d_savedQueueIndex = d_savedQueueIndex + 1; + } + + while(d_nextInputConstraintToEnqueue < d_inputConstraints.size() && !inConflict()){ + size_t curr = d_nextInputConstraintToEnqueue; + d_nextInputConstraintToEnqueue = d_nextInputConstraintToEnqueue + 1; + + TrailIndex i = d_inputConstraints[curr].d_trailPos; + TrailIndex j = applyAllSubstitutionsToIndex(i); + + if(!(triviallySat(j) || anyCoefficientExceedsMaximum(j))){ + if(triviallyUnsat(j)){ + raiseConflict(j); + }else{ + TrailIndex k = reduceByGCD(j); + + if(!inConflict()){ + if(triviallyUnsat(k)){ + raiseConflict(k); + }else if(!triviallySat(k)){ + pushToQueueBack(k); + } } } - if(!foundConstant) { - // calculate gcd of all (NON-constant) coefficients - gcd = (gcd == 0) ? r.getNumerator().abs() : gcd.gcd(r.getNumerator()); - Debug("integers") << " gcd now " << gcd << endl; + } + } +} + + +/*TODO Currently linear in the size of the Queue + *It is not clear if am O(log n) strategy would be better. + *Right before this in the algorithm is a substition which could potentially + *effect the key values of everything in the queue. + */ +void DioSolver::moveMinimumByAbsToQueueFront(){ + Assert(!queueEmpty()); + + + //Select the minimum element. + size_t indexInQueue = 0; + Monomial minMonomial = d_trail[d_currentF[indexInQueue]].d_minimalMonomial; + + size_t N = d_currentF.size(); + for(size_t i=1; i < N; ++i){ + Monomial curr = d_trail[d_currentF[i]].d_minimalMonomial; + if(curr.absLessThan(minMonomial)){ + indexInQueue = i; + minMonomial = curr; + } + } + + TrailIndex tmp = d_currentF[indexInQueue]; + d_currentF[indexInQueue] = d_currentF.front(); + d_currentF.front() = tmp; +} + +bool DioSolver::queueEmpty() const{ + return d_currentF.empty(); +} + +Node DioSolver::columnGcdIsOne() const{ + std::hash_map gcdMap; + + std::deque::const_iterator iter, end; + for(iter = d_currentF.begin(), end = d_currentF.end(); iter != end; ++iter){ + TrailIndex curr = *iter; + Polynomial p = d_trail[curr].d_eq.getPolynomial(); + Polynomial::iterator monoIter = p.begin(), monoEnd = p.end(); + for(; monoIter != monoEnd; ++monoIter){ + Monomial m = *monoIter; + VarList vl = m.getVarList(); + Node vlNode = vl.getNode(); + + Constant c = m.getConstant(); + Integer zc = c.getValue().getNumerator(); + if(gcdMap.find(vlNode) == gcdMap.end()){ + // have not seen vl yet. + // gcd is c + Assert(c.isIntegral()); + Assert(!m.absCoefficientIsOne()); + gcdMap.insert(make_pair(vlNode, zc.abs())); + }else{ + const Integer& currentGcd = gcdMap[vlNode]; + Integer newGcd = currentGcd.gcd(zc); + if(newGcd == 1){ + return vlNode; + }else{ + gcdMap[vlNode] = newGcd; + } } } - Debug("integers") << "addEquation: gcd is " << gcd << ", c is " << c << endl; - // The gcd must divide c for this equation to be satisfiable. - // If c is not an integer, there's no way it can. - if(c.getDenominator() == 1 && gcd == gcd.gcd(c.getNumerator())) { - Trace("integers") << "addEquation: this eqn is fine" << endl; - } else { - Trace("integers") << "addEquation: eqn not satisfiable, returning false" << endl; - return false; + } + return Node::null(); +} + +void DioSolver::saveQueue(){ + std::deque::const_iterator iter, end; + for(iter = d_currentF.begin(), end = d_currentF.end(); iter != end; ++iter){ + d_savedQueue.push_back(*iter); + } +} + +DioSolver::TrailIndex DioSolver::impliedGcdOfOne(){ + Node canReduce = columnGcdIsOne(); + if(canReduce.isNull()){ + return 0; + }else{ + VarList vl = VarList::parseVarList(canReduce); + + TrailIndex current; + Integer currentCoeff, currentGcd; + + //step 1 find the first equation containing vl + //Set current and currentCoefficient + std::deque::const_iterator iter, end; + for(iter = d_currentF.begin(), end = d_currentF.end(); true; ++iter){ + Assert(iter != end); + current = *iter; + Constant coeff = d_trail[current].d_eq.getPolynomial().getCoefficient(vl); + if(!coeff.isZero()){ + currentCoeff = coeff.getValue().getNumerator(); + currentGcd = currentCoeff.abs(); + + ++iter; + break; + } + } + + //For the rest of the equations keep reducing until the coefficient is one + for(; iter != end; ++iter){ + TrailIndex inQueue = *iter; + Constant iqc = d_trail[inQueue].d_eq.getPolynomial().getCoefficient(vl); + if(!iqc.isZero()){ + Integer inQueueCoeff = iqc.getValue().getNumerator(); + + //mpz_gcdext (mpz_t g, mpz_t s, mpz_t t, mpz_t a, mpz_t b); + Integer g, s, t; + // g = a*s + b*t + Integer::extendedGcd(g, s, t, currentCoeff, inQueueCoeff); + + Debug("arith::dio") << "extendedReduction" << endl; + Debug("arith::dio") << g << " = " << s <<"*"<< currentCoeff << " + " << t <<"*"<< inQueueCoeff << endl; + + Assert(g <= currentGcd); + if(g < currentGcd){ + if(s.sgn() == 0){ + Debug("arith::dio") << "extendedReduction drop" << endl; + Assert(inQueueCoeff.divides(currentGcd)); + current = *iter; + currentCoeff = inQueueCoeff; + currentGcd = inQueueCoeff; + }else{ + Debug("arith::dio") << "extendedReduction combine" << endl; + + TrailIndex next = combineEqAtIndexes(current, s, inQueue, t); + + Assert(d_trail[next].d_eq.getPolynomial().getCoefficient(vl).getValue().getNumerator() == g); + + current = next; + currentCoeff = g; + currentGcd = g; + if(currentGcd == 1){ + return current; + } + } + } + } + } + //This is not reachble as it is assured that the gcd of the column is 1 + Unreachable(); + } +} + +bool DioSolver::processEquations(bool allowDecomposition){ + Assert(!inConflict()); + + enqueueInputConstraints(); + while(! queueEmpty() && !inConflict()){ + moveMinimumByAbsToQueueFront(); + + TrailIndex minimum = d_currentF.front(); + TrailIndex reduceIndex; + + Assert(inRange(minimum)); + Assert(!inConflict()); + + Debug("arith::dio") << "processEquations " << minimum << " : " << d_trail[minimum].d_eq.getNode() << endl; + + Assert(queueConditions(minimum)); + + bool canDirectlySolve = d_trail[minimum].d_minimalMonomial.absCoefficientIsOne(); + + std::pair p; + if(canDirectlySolve){ + d_currentF.pop_front(); + p = solveIndex(minimum); + reduceIndex = minimum; + }else{ + TrailIndex implied = impliedGcdOfOne(); + + if(implied != 0){ + p = solveIndex(implied); + reduceIndex = implied; + }else if(allowDecomposition){ + d_currentF.pop_front(); + p = decomposeIndex(minimum); + reduceIndex = minimum; + }else { + // Cannot make progress without decomposeIndex + saveQueue(); + break; + } + } + + SubIndex subIndex = p.first; + TrailIndex next = p.second; + subAndReduceCurrentFByIndex(subIndex); + + if(next != reduceIndex){ + if(triviallyUnsat(next)){ + raiseConflict(next); + }else if(! triviallySat(next) ){ + pushToQueueBack(next); + } } } - return true; + d_currentF.clear(); + return inConflict(); } -void DioSolver::getSolution() { - Unimplemented(); +Node DioSolver::processEquationsForConflict(){ + TimerStat::CodeTimer codeTimer(d_statistics.d_conflictTimer); + ++(d_statistics.d_conflictCalls); + + Assert(!inConflict()); + if(processEquations(false)){ + ++(d_statistics.d_conflicts); + return proveIndex(getConflictIndex()); + }else{ + return Node::null(); + } +} + +SumPair DioSolver::processEquationsForCut(){ + TimerStat::CodeTimer codeTimer(d_statistics.d_cutTimer); + ++(d_statistics.d_cutCalls); + + Assert(!inConflict()); + if(processEquations(true)){ + ++(d_statistics.d_cuts); + return purifyIndex(getConflictIndex()); + }else{ + return SumPair::mkZero(); + } +} + + +SumPair DioSolver::purifyIndex(TrailIndex i){ +#warning "This uses the substition trail to reverse the substitions from the sum term. Using the proof term should be more efficient." + + SumPair curr = d_trail[i].d_eq; + + Constant negOne = Constant::mkConstant(-1); + + for(uint32_t revIter = d_subs.size(); revIter > 0; --revIter){ + uint32_t i = revIter - 1; + Node freshNode = d_subs[i].d_fresh; + if(freshNode.isNull()){ + continue; + }else{ + Variable var(freshNode); + Polynomial vsum = curr.getPolynomial(); + + Constant a = vsum.getCoefficient(VarList(var)); + if(!a.isZero()){ + const SumPair& sj = d_trail[d_subs[i].d_constraint].d_eq; + Assert(sj.getPolynomial().getCoefficient(VarList(var)).isOne()); + SumPair newSi = (curr * negOne) + (sj * a); + Assert(newSi.getPolynomial().getCoefficient(VarList(var)).isZero()); + curr = newSi; + } + } + } + return curr; +} + +DioSolver::TrailIndex DioSolver::combineEqAtIndexes(DioSolver::TrailIndex i, const Integer& q, DioSolver::TrailIndex j, const Integer& r){ + Constant cq = Constant::mkConstant(q); + Constant cr = Constant::mkConstant(r); + + const SumPair& si = d_trail[i].d_eq; + const SumPair& sj = d_trail[j].d_eq; + + Debug("arith::dio") << "combineEqAtIndexes(" << i <<","< DioSolver::decomposeIndex(DioSolver::TrailIndex i){ + const SumPair& si = d_trail[i].d_eq; + + d_usedDecomposeIndex = true; + + Debug("arith::dio") << "before decomposeIndex("< 1); + + //It is not sufficient to reduce the case where abs(a) == 1 to abs(a) > 1. + //We need to handle both cases seperately to ensure termination. + Node qr = SumPair::computeQR(si, a.getValue().getNumerator()); + + Assert(qr.getKind() == kind::PLUS); + Assert(qr.getNumChildren() == 2); + SumPair q = SumPair::parseSumPair(qr[0]); + SumPair r = SumPair::parseSumPair(qr[1]); + + Assert(q.getPolynomial().getCoefficient(vl) == Constant::mkConstant(1)); + + Assert(!r.isZero()); + Node freshNode = makeIntegerVariable(); + Variable fresh(freshNode); + SumPair fresh_one=SumPair::mkSumPair(fresh); + SumPair fresh_a = fresh_one * a; + + SumPair newSI = SumPair(fresh_one) - q; + // this normalizes the coefficient of var to -1 + + + TrailIndex ci = d_trail.size(); + d_trail.push_back(Constraint(newSI, Polynomial::mkZero())); + + Debug("arith::dio") << "Decompose ci(" << ci <<":" << d_trail[ci].d_eq.getNode() + << ") for " << av.getNode() << endl; + Assert(d_trail[ci].d_eq.getPolynomial().getCoefficient(vl) == Constant::mkConstant(-1)); + + SumPair newFact = r + fresh_a; + + TrailIndex nextIndex = d_trail.size(); + d_trail.push_back(Constraint(newFact, d_trail[i].d_proof)); + + SubIndex subBy = d_subs.size(); + d_subs.push_back(Substitution(freshNode, var, ci)); + + Debug("arith::dio") << "Decompose nextIndex " << d_trail[nextIndex].d_eq.getNode() << endl; + return make_pair(subBy, nextIndex); +} + + +DioSolver::TrailIndex DioSolver::applySubstitution(DioSolver::SubIndex si, DioSolver::TrailIndex ti){ + Variable var = d_subs[si].d_eliminated; + TrailIndex subIndex = d_subs[si].d_constraint; + + const SumPair& curr = d_trail[ti].d_eq; + Polynomial vsum = curr.getPolynomial(); + + Constant a = vsum.getCoefficient(VarList(var)); + Assert(a.isIntegral()); + if(!a.isZero()){ + Integer one(1); + TrailIndex afterSub = combineEqAtIndexes(ti, one, subIndex, a.getValue().getNumerator()); + Assert(d_trail[afterSub].d_eq.getPolynomial().getCoefficient(VarList(var)).isZero()); + return afterSub; + }else{ + return ti; + } +} + + +DioSolver::TrailIndex DioSolver::reduceByGCD(DioSolver::TrailIndex ti){ + const SumPair& sp = d_trail[ti].d_eq; + Polynomial vsum = sp.getPolynomial(); + Constant c = sp.getConstant(); + + Debug("arith::dio") << "reduceByGCD " << vsum.getNode() << endl; + Assert(!vsum.isConstant()); + Integer g = vsum.gcd(); + Assert(g >= 1); + Debug("arith::dio") << "gcd("<< vsum.getNode() <<")=" << g << " " << c.getValue() << endl; + if(g.divides(c.getValue().getNumerator())){ + if(g > 1){ + return scaleEqAtIndex(ti, g); + }else{ + return ti; + } + }else{ + raiseConflict(ti); + return ti; + } +} + +bool DioSolver::triviallySat(TrailIndex i){ + const SumPair& eq = d_trail[i].d_eq; + if(eq.isConstant()){ + return eq.getConstant().isZero(); + }else{ + return false; + } +} + +bool DioSolver::triviallyUnsat(DioSolver::TrailIndex i){ + const SumPair& eq = d_trail[i].d_eq; + if(eq.isConstant()){ + return !eq.getConstant().isZero(); + }else{ + return false; + } +} + + +bool DioSolver::gcdIsOne(DioSolver::TrailIndex i){ + const SumPair& eq = d_trail[i].d_eq; + return eq.gcd() == Integer(1); +} + +void DioSolver::debugPrintTrail(DioSolver::TrailIndex i) const{ + const SumPair& eq = d_trail[i].d_eq; + const Polynomial& proof = d_trail[i].d_proof; + + cout << "d_trail["< #include @@ -36,33 +38,384 @@ namespace theory { namespace arith { class DioSolver { - context::Context* d_context; - const Tableau& d_tableau; - ArithPartialModel& d_partialModel; +private: + typedef size_t TrailIndex; + typedef size_t InputConstraintIndex; + typedef size_t SubIndex; + + std::vector d_variablePool; + context::CDO d_lastUsedVariable; + + /** + * The set of input constraints is stored in a CDList. + * Each constraint point to an element of the trail. + */ + struct InputConstraint { + Node d_reason; + TrailIndex d_trailPos; + InputConstraint(Node reason, TrailIndex pos) : d_reason(reason), d_trailPos(pos) {} + }; + context::CDList d_inputConstraints; + + /** + * This is the next input constraint to handle. + */ + context::CDO d_nextInputConstraintToEnqueue; + + + /** + * We maintain a map from the variables associated with proofs to an input constraint. + * These variables can then be used in polynomial manipulations. + */ + typedef std::hash_map NodeToInputConstraintIndexMap; + NodeToInputConstraintIndexMap d_varToInputConstraintMap; + + Node proofVariableToReason(const Variable& v) const{ + Assert(d_varToInputConstraintMap.find(v.getNode()) != d_varToInputConstraintMap.end()); + InputConstraintIndex pos = (*(d_varToInputConstraintMap.find(v.getNode()))).second; + Assert(pos < d_inputConstraints.size()); + return d_inputConstraints[pos].d_reason; + } + + /** + * The main work horse of the algorithm, the trail of constraints. + * Each constraint is a SumPair that implicitly represents an equality against 0. + * d_trail[i].d_eq = (+ c (+ [(* coeff var)])) representing (+ [(* coeff var)]) = -c + * Each constraint has a proof in terms of a linear combination of the input constraints. + * d_trail[i].d_proof + * + * Each Constraint also a monomial in d_eq.getPolynomial() + * of minimal absolute value by the coefficients. + * d_trail[i].d_minimalMonomial + * + * See Alberto's paper for how linear proofs are maintained for the abstract + * state machine in rules (7), (8) and (9). + */ + struct Constraint { + SumPair d_eq; + Polynomial d_proof; + Monomial d_minimalMonomial; + Constraint(const SumPair& eq, const Polynomial& p) : + d_eq(eq), d_proof(p), d_minimalMonomial(d_eq.getPolynomial().selectAbsMinimum()) + {} + }; + context::CDList d_trail; + + /** Compare by d_minimal. */ + struct TrailMinimalCoefficientOrder { + const context::CDList& d_trail; + TrailMinimalCoefficientOrder(const context::CDList& trail): + d_trail(trail) + {} + + bool operator()(TrailIndex i, TrailIndex j){ + return d_trail[i].d_minimalMonomial.absLessThan(d_trail[j].d_minimalMonomial); + } + }; + + /** + * A substitution is stored as a constraint in the trail together with + * the variable to be eliminated, and a fresh variable if one was introduced. + * The variable d_subs[i].d_eliminated is substituted using the implicit equality in + * d_trail[d_subs[i].d_constraint] + * - d_subs[i].d_eliminated is normalized to have coefficient -1 in + * d_trail[d_subs[i].d_constraint]. + * - d_subs[i].d_fresh is either Node::null() or it is variable it is normalized + * to have coefficient 1 in d_trail[d_subs[i].d_constraint]. + */ + struct Substitution { + Node d_fresh; + Variable d_eliminated; + TrailIndex d_constraint; + Substitution(Node f, const Variable& e, TrailIndex c) : + d_fresh(f), d_eliminated(e), d_constraint(c) + {} + }; + context::CDList d_subs; + + /** + * This is the queue of constraints to be processed in the current context level. + * This is to be empty upon entering solver and cleared upon leaving the solver. + * + * All elements in currentF: + * - are fully substituted according to d_subs. + * - !isConstant(). + * - If the element is (+ constant (+ [(* coeff var)] )), then the gcd(coeff) = 1 + */ + std::deque d_currentF; + context::CDList d_savedQueue; + context::CDO d_savedQueueIndex; + + context::CDO d_conflictHasBeenRaised; + TrailIndex d_conflictIndex; + + /** + * Drop derived constraints with a coefficient length larger than + * the maximum input constraints length than 2**MAX_GROWTH_RATE. + */ + context::CDO d_maxInputCoefficientLength; + static const uint32_t MAX_GROWTH_RATE = 3; + + /** Returns true if the element on the trail should be dropped.*/ + bool anyCoefficientExceedsMaximum(TrailIndex j) const; + + /** + * Is true if decomposeIndex has been used in this context. + */ + context::CDO d_usedDecomposeIndex; + + context::CDO d_lastPureSubstitution; + context::CDO d_pureSubstitionIter; public: /** Construct a Diophantine equation solver with the given context. */ - DioSolver(context::Context* ctxt, const Tableau& tab, ArithPartialModel& pmod) : - d_context(ctxt), - d_tableau(tab), - d_partialModel(pmod) { + DioSolver(context::Context* ctxt); + + /** Returns true if the substitutions use no new variables. */ + bool hasMorePureSubstitutions() const{ + return d_pureSubstitionIter < d_lastPureSubstitution; + } + + Node nextPureSubstitution(); + + /** + * Adds an equality to the queue of the DioSolver. + * orig is blamed in a conflict. + * orig can either be of the form (= p c) or (and ub lb). + * where ub is either (leq p c) or (not (> p [- c 1])), and + * where lb is either (geq p c) or (not (< p [+ c 1])) + */ + void pushInputConstraint(const Comparison& eq, Node reason); + + /** + * Processes the queue looking for any conflict. + * If a conflict is found, this returns conflict. + * Otherwise, it returns null. + * The conflict is guarenteed to be over literals given in addEquality. + */ + Node processEquationsForConflict(); + + /** + * Processes the queue looking for an integer unsatisfiable cutting plane. + * If such a plane is found this returns an entailed plane using no + * fresh variables. + */ + SumPair processEquationsForCut(); + +private: + /** Returns true if the TrailIndex refers to a element in the trail. */ + bool inRange(TrailIndex i) const{ + return i < d_trail.size(); + } + + Node columnGcdIsOne() const; + + + /** + * Returns true if the context dependent flag for conflicts + * has been raised. + */ + bool inConflict() const{ + return d_conflictHasBeenRaised; + } + + /** Raises a conflict at the index ti. */ + void raiseConflict(TrailIndex ti){ + Assert(!inConflict()); + d_conflictHasBeenRaised = true; + d_conflictIndex = ti; + } + + /** Returns the conflict index. */ + TrailIndex getConflictIndex() const{ + Assert(inConflict()); + return d_conflictIndex; + } + + /** + * Allocates a "unique" variables from the pool of integer variables. + * This variable is fresh with respect to the context. + * Returns index of the variable in d_variablePool; + */ + size_t allocateVariableInPool(); + + /** + * Returns true if the node can be accepted as a reason according to the + * kinds. + */ + bool acceptableOriginalNodes(Node n); + + /** Empties the unproccessed input constraints into the queue. */ + void enqueueInputConstraints(); + + /** + * Returns true if an input equality is in the map. + * This is expensive and is only for debug assertions. + */ + bool debugEqualityInInputEquations(Node eq); + + /** Applies the substitution at subIndex to currentF. */ + void subAndReduceCurrentFByIndex(SubIndex d_subIndex); + + /** + * Takes as input a TrailIndex i and an integer that divides d_trail[i].d_eq, and + * returns a TrailIndex j s.t. + * d_trail[j].d_eq = (1/g) d_trail[i].d_eq + * and + * d_trail[j].d_proof = (1/g) d_trail[i].d_proof. + * + * g must be non-zero. + * + * This corresponds to an application of Alberto's rule (7). + */ + TrailIndex scaleEqAtIndex(TrailIndex i, const Integer& g); + + + /** + * Takes as input TrailIndex's i and j and Integer's q and r and a TrailIndex k s.t. + * d_trail[k].d_eq == d_trail[i].d_eq * q + d_trail[j].d_eq * r + * and + * d_trail[k].d_proof == d_trail[i].d_proof * q + d_trail[j].d_proof * r + * + * This corresponds to an application of Alberto's rule (8). + */ + TrailIndex combineEqAtIndexes(TrailIndex i, const Integer& q, TrailIndex j, const Integer& r); + + /** + * Decomposes the equation at index ti of trail by the variable + * with the lowest coefficient. + * This corresponds to an application of Alberto's rule (9). + * + * Returns a pair of a SubIndex and a TrailIndex. + * The SubIndex is the index of a newly introduced substition. + */ + std::pair decomposeIndex(TrailIndex ti); + + /** Solves the index at ti for the value in minimumMonomial. */ + std::pair solveIndex(TrailIndex ti); + + /** Prints the queue for debugging purposes to Debug("arith::dio"). */ + void printQueue(); + + /** + * Exhaustively applies all substitutions discovered to an element of the trail. + * Returns a TrailIndex corresponding to the substitutions being applied. + */ + TrailIndex applyAllSubstitutionsToIndex(TrailIndex i); + + /** + * Applies a substitution to an element in the trail. + */ + TrailIndex applySubstitution(SubIndex s, TrailIndex i); + + /** + * Reduces the trail node at i by the gcd of the variables. + * Returns the new trail element. + * + * This raises the conflict flag if unsat is detected. + */ + TrailIndex reduceByGCD(TrailIndex i); + + /** + * Returns true if i'th element in the trail is trivially true. + * (0 = 0) + */ + bool triviallySat(TrailIndex t); + + /** + * Returns true if i'th element in the trail is trivially unsatisfiable. + * (1 = 0) + */ + bool triviallyUnsat(TrailIndex t); + + /** Returns true if the gcd of the i'th element of the trail is 1.*/ + bool gcdIsOne(TrailIndex t); + + bool debugAnySubstitionApplies(TrailIndex t); + bool debugSubstitutionApplies(SubIndex si, TrailIndex ti); + + + /** Returns true if the queue of nodes to process is empty. */ + bool queueEmpty() const; + + bool queueConditions(TrailIndex t){ + /* debugPrintTrail(t); */ + + /* std::cout << !inConflict() << std::endl; */ + /* std::cout << gcdIsOne(t) << std::endl; */ + /* std::cout << !debugAnySubstitionApplies(t) << std::endl; */ + /* std::cout << !triviallySat(t) << std::endl; */ + /* std::cout << !triviallyUnsat(t) << std::endl; */ + + return + !inConflict() && + gcdIsOne(t) && + !debugAnySubstitionApplies(t) && + !triviallySat(t) && + !triviallyUnsat(t); + } + + void pushToQueueBack(TrailIndex t){ + Assert(queueConditions(t)); + d_currentF.push_back(t); + } + + void pushToQueueFront(TrailIndex t){ + Assert(queueConditions(t)); + d_currentF.push_front(t); } /** - * Solve the set of Diophantine equations in the tableau. + * Moves the minimum Constraint by absolute value of the minimum coefficient to + * the front of the queue. + */ + void moveMinimumByAbsToQueueFront(); + + void saveQueue(); + + TrailIndex impliedGcdOfOne(); + + + /** + * Processing the current set of equations. * - * @return true if the set of equations was solved; false if no - * solution + * decomposeIndex() rule is only applied if allowDecomposition is true. */ - bool solve(); + bool processEquations(bool allowDecomposition); /** - * Get the parameterized solution to this set of Diophantine - * equations. Must be preceded by a call to solve() that returned - * true. */ - void getSolution(); + * Constructs a proof from any d_trail[i] in terms of input literals. + */ + Node proveIndex(TrailIndex i); + + /** + * Returns the SumPair in d_trail[i].d_eq with all of the fresh variables purified out. + */ + SumPair purifyIndex(TrailIndex i); + + + void debugPrintTrail(TrailIndex i) const; + +public: + /** These fields are designed to be accessable to TheoryArith methods. */ + class Statistics { + public: + + IntStat d_conflictCalls; + IntStat d_cutCalls; + + IntStat d_cuts; + IntStat d_conflicts; + + TimerStat d_conflictTimer; + TimerStat d_cutTimer; + + Statistics(); + ~Statistics(); + }; + Statistics d_statistics; };/* class DioSolver */ }/* CVC4::theory::arith namespace */ diff --git a/src/theory/arith/normal_form.cpp b/src/theory/arith/normal_form.cpp index e7df14df7..a4dc78c9f 100644 --- a/src/theory/arith/normal_form.cpp +++ b/src/theory/arith/normal_form.cpp @@ -21,9 +21,10 @@ #include using namespace std; -using namespace CVC4; -using namespace CVC4::theory; -using namespace CVC4::theory::arith; + +namespace CVC4 { +namespace theory{ +namespace arith { bool VarList::isSorted(iterator start, iterator end) { return __gnu_cxx::is_sorted(start, end); @@ -131,9 +132,6 @@ Monomial Monomial::operator*(const Monomial& mono) const { vector Monomial::sumLikeTerms(const std::vector & monos) { Assert(isSorted(monos)); - - Debug("blah") << "start sumLikeTerms" << std::endl; - printList(monos); vector outMonomials; typedef vector::const_iterator iterator; for(iterator rangeIter = monos.begin(), end=monos.end(); rangeIter != end;) { @@ -150,9 +148,6 @@ vector Monomial::sumLikeTerms(const std::vector & monos) { outMonomials.push_back(nonZero); } } - Debug("blah") << "outmonomials" << std::endl; - printList(monos); - Debug("blah") << "end sumLikeTerms" << std::endl; Assert(isStrictlySorted(outMonomials)); return outMonomials; @@ -169,8 +164,6 @@ void Monomial::printList(const std::vector& list) { } } Polynomial Polynomial::operator+(const Polynomial& vl) const { - this->printList(); - vl.printList(); std::vector sortedMonos; merge_ranges(begin(), end(), vl.begin(), vl.end(), sortedMonos); @@ -178,7 +171,6 @@ Polynomial Polynomial::operator+(const Polynomial& vl) const { std::vector combined = Monomial::sumLikeTerms(sortedMonos); Polynomial result = mkPolynomial(combined); - result.printList(); return result; } @@ -211,9 +203,47 @@ Polynomial Polynomial::operator*(const Polynomial& poly) const { return res; } +Monomial Polynomial::selectAbsMinimum() const { + iterator iter = begin(), myend = end(); + Assert(iter != myend); + + Monomial min = *iter; + ++iter; + for(; iter != end(); ++iter){ + Monomial curr = *iter; + if(curr.absLessThan(min)){ + min = curr; + } + } + return min; +} + +Integer Polynomial::gcd() const { + //We'll use the standardization that gcd(0, 0) = 0 + //So that the gcd of the zero polynomial is gcd{0} = 0 + Assert(isIntegral()); + iterator i=begin(), e=end(); + Assert(i!=e); + + Integer d = (*i).getConstant().getValue().getNumerator().abs(); + ++i; + for(; i!=e; ++i){ + Integer c = (*i).getConstant().getValue().getNumerator(); + d = d.gcd(c); + } + return d; +} + +Integer Polynomial::denominatorLCM() const { + Integer tmp(1); + for(iterator i=begin(), e=end(); i!=e; ++i){ + const Constant& c = (*i).getConstant(); + tmp = tmp.lcm(c.getValue().getDenominator()); + } + return tmp; +} Node Comparison::toNode(Kind k, const Polynomial& l, const Constant& r) { - Assert(!l.isConstant()); Assert(isRelationOperator(k)); switch(k) { case kind::GEQ: @@ -306,22 +336,27 @@ bool Comparison::pbComparison(Kind k, TNode left, const Rational& right, bool& r return false; } +// Comparison Comparison::mkComparison(Kind k, const Polynomial& left, const Constant& right) { +// Assert(isRelationOperator(k)); +// if(left.isConstant()) { +// const Rational& lConst = left.getNode().getConst(); +// const Rational& rConst = right.getNode().getConst(); +// bool res = evaluateConstantPredicate(k, lConst, rConst); +// return Comparison(res); +// } + +// if(left.getNode().getType().isPseudoboolean()) { +// bool result; +// if(pbComparison(k, left.getNode(), right.getNode().getConst(), result)) { +// return Comparison(result); +// } +// } + +// return Comparison(toNode(k, left, right), k, left, right); +// } + Comparison Comparison::mkComparison(Kind k, const Polynomial& left, const Constant& right) { Assert(isRelationOperator(k)); - if(left.isConstant()) { - const Rational& lConst = left.getNode().getConst(); - const Rational& rConst = right.getNode().getConst(); - bool res = evaluateConstantPredicate(k, lConst, rConst); - return Comparison(res); - } - - if(left.getNode().getType().isPseudoboolean()) { - bool result; - if(pbComparison(k, left.getNode(), right.getNode().getConst(), result)) { - return Comparison(result); - } - } - return Comparison(toNode(k, left, right), k, left, right); } @@ -334,9 +369,231 @@ Comparison Comparison::addConstant(const Constant& constant) const { return mkComparison(oper, newLeft, newRight); } +bool Comparison::constantInLefthand() const{ + return getLeft().containsConstant(); +} + +Comparison Comparison::cancelLefthandConstant() const { + if(constantInLefthand()){ + Monomial constantHead = getLeft().getHead(); + Assert(constantHead.isConstant()); + + Constant constant = constantHead.getConstant(); + Constant negativeConstantHead = -constant; + return addConstant(negativeConstantHead); + }else{ + return *this; + } +} + Comparison Comparison::multiplyConstant(const Constant& constant) const { Assert(!isBoolean()); Kind newOper = (constant.getValue() < 0) ? reverseRelationKind(oper) : oper; return mkComparison(newOper, left*Monomial(constant), right*constant); } + +Integer Comparison::denominatorLCM() const { + // Get the coefficients to be all integers. + Integer leftDenominatorLCM = left.denominatorLCM(); + Integer rightDenominator = right.getValue().getDenominator(); + Integer denominatorLCM = leftDenominatorLCM.lcm(rightDenominator); + Assert(denominatorLCM.sgn() > 0); + return denominatorLCM; +} + +Comparison Comparison::multiplyByDenominatorLCM() const{ + return multiplyConstant(Constant::mkConstant(denominatorLCM())); +} + +Comparison Comparison::normalizeLeadingCoefficientPositive() const { + if(getLeft().getHead().getConstant().isNegative()){ + return multiplyConstant(Constant::mkConstant(-1)); + }else{ + return *this; + } +} + +bool Comparison::isIntegral() const { + return getRight().isIntegral() && getLeft().isIntegral(); +} + +bool Comparison::isConstant() const { + return getLeft().isConstant(); +} + +Comparison Comparison::evaluateConstant() const { + Assert(left.isConstant()); + const Rational& rConst = getRight().getValue(); + const Rational& lConst = getLeft().getHead().getConstant().getValue(); + bool res = evaluateConstantPredicate(getKind(), lConst, rConst); + return Comparison(res); +} + +Comparison Comparison::divideByLefthandGCD() const { + Assert(isIntegral()); + + Integer zr = getRight().getValue().getNumerator(); + Integer gcd = getLeft().gcd(); + Polynomial newLeft = getLeft().exactDivide(gcd); + + Constant newRight = Constant::mkConstant(Rational(zr,gcd)); + return mkComparison(getKind(), newLeft, newRight); +} + +Comparison Comparison::divideByLeadingCoefficient() const { + //Handle the rational/mixed case + Monomial head = getLeft().getHead(); + Constant leadingCoefficient = head.getConstant(); + Assert(!leadingCoefficient.isZero()); + + Constant inverse = leadingCoefficient.inverse(); + + return multiplyConstant(inverse); +} + +Comparison Comparison::tightenIntegralConstraint() const { + Assert(getLeft().isIntegral()); + + if(getRight().isIntegral()){ + return *this; + }else{ + switch(getKind()){ + case kind::EQUAL: + //If the gcd of the left hand side does not cleanly divide the right hand side, + //this is unsatisfiable in the theory of Integers. + return Comparison(false); + case kind::GEQ: + case kind::GT: + { + //(>= l (/ n d)) + //(>= l (ceil (/ n d))) + //This also hold for GT as (ceil (/ n d)) > (/ n d) + Integer ceilr = getRight().getValue().ceiling(); + Constant newRight = Constant::mkConstant(ceilr); + return Comparison(toNode(kind::GEQ, getLeft(), newRight),kind::GEQ, getLeft(),newRight); + } + case kind::LEQ: + case kind::LT: + { + //(<= l (/ n d)) + //(<= l (floor (/ n d))) + //This also hold for LT as (floor (/ n d)) < (/ n d) + Integer floor = getRight().getValue().floor(); + Constant newRight = Constant::mkConstant(floor); + return Comparison(toNode(kind::LEQ, getLeft(), newRight),kind::LEQ, getLeft(),newRight); + } + default: + Unreachable(); + } + } +} + +bool Comparison::isIntegerNormalForm() const{ + if(constantInLefthand()){ return false; } + else if(getLeft().getHead().getConstant().isNegative()){ return false; } + else if(!isIntegral()){ return false; } + else { + return getLeft().gcd() == 1; + } +} +bool Comparison::isMixedNormalForm() const { + if(constantInLefthand()){ return false; } + else if(allIntegralVariables()) { return false; } + else{ + return getLeft().getHead().getConstant().getValue() == 1; + } +} + +Comparison Comparison::normalize(Comparison c) { + if(c.isConstant()){ + return c.evaluateConstant(); + }else{ + Comparison c0 = c.constantInLefthand() ? c.cancelLefthandConstant() : c; + Comparison c1 = c0.normalizeLeadingCoefficientPositive(); + if(c1.allIntegralVariables()){ + //All Integer Variable Case + Comparison integer0 = c1.multiplyByDenominatorLCM(); + Comparison integer1 = integer0.divideByLefthandGCD(); + Comparison integer2 = integer1.tightenIntegralConstraint(); + Assert(integer2.isBoolean() || integer2.isIntegerNormalForm()); + return integer2; + }else{ + //Mixed case + Comparison mixed = c1.divideByLeadingCoefficient(); + Assert(mixed.isMixedNormalForm()); + return mixed; + } + } +} + +Comparison Comparison::mkNormalComparison(Kind k, const Polynomial& left, const Constant& right) { + Comparison cmp = mkComparison(k,left,right); + Comparison normalized = cmp.normalize(cmp); + Assert(normalized.isNormalForm()); + return normalized; +} + +Node Polynomial::computeQR(const Polynomial& p, const Integer& div){ + Assert(p.isIntegral()); + std::vector q_vec, r_vec; + Integer tmp_q, tmp_r; + for(iterator iter = p.begin(), pend = p.end(); iter != pend; ++iter){ + Monomial curr = *iter; + VarList vl = curr.getVarList(); + Constant c = curr.getConstant(); + + const Integer& a = c.getValue().getNumerator(); + Integer::floorQR(tmp_q, tmp_r, a, div); + Constant q=Constant::mkConstant(tmp_q); + Constant r=Constant::mkConstant(tmp_r); + if(!q.isZero()){ + q_vec.push_back(Monomial::mkMonomial(q, vl)); + } + if(!r.isZero()){ + r_vec.push_back(Monomial::mkMonomial(r, vl)); + } + } + + Polynomial p_q = Polynomial::mkPolynomial(q_vec); + Polynomial p_r = Polynomial::mkPolynomial(r_vec); + + return NodeManager::currentNM()->mkNode(kind::PLUS, p_q.getNode(), p_r.getNode()); +} + +Node SumPair::computeQR(const SumPair& sp, const Integer& div){ + Assert(sp.isIntegral()); + + const Integer& constant = sp.getConstant().getValue().getNumerator(); + + Integer constant_q, constant_r; + Integer::floorQR(constant_q, constant_r, constant, div); + + Node p_qr = Polynomial::computeQR(sp.getPolynomial(), div); + Assert(p_qr.getKind() == kind::PLUS); + Assert(p_qr.getNumChildren() == 2); + + Polynomial p_q = Polynomial::parsePolynomial(p_qr[0]); + Polynomial p_r = Polynomial::parsePolynomial(p_qr[1]); + + SumPair sp_q(p_q, Constant::mkConstant(constant_q)); + SumPair sp_r(p_r, Constant::mkConstant(constant_r)); + + return NodeManager::currentNM()->mkNode(kind::PLUS, sp_q.getNode(), sp_r.getNode()); +} + +Constant Polynomial::getCoefficient(const VarList& vl) const{ + //TODO improve to binary search... + for(iterator iter=begin(), myend=end(); iter != myend; ++iter){ + Monomial m = *iter; + VarList curr = m.getVarList(); + if(curr == vl){ + return m.getConstant(); + } + } + return Constant::mkConstant(0); +} + +} //namespace arith +} //namespace theory +} //namespace CVC4 diff --git a/src/theory/arith/normal_form.h b/src/theory/arith/normal_form.h index a1a33fed0..71d7c96f4 100644 --- a/src/theory/arith/normal_form.h +++ b/src/theory/arith/normal_form.h @@ -50,6 +50,7 @@ namespace arith { * variable := n * where * n.getMetaKind() == metakind::VARIABLE + * n.getType() \in {Integer, Real} * * constant := n * where @@ -70,13 +71,24 @@ namespace arith { * isStrictlySorted monoOrder [monomial] * forall (\x -> x != 0) [monomial] * - * restricted_cmp := (|><| polynomial constant) + * rational_restricted_cmp := (|><| qpolynomial constant) * where * |><| is GEQ, EQ, or EQ - * not (exists constantMonomial (monomialList polynomial)) - * monomialCoefficient (head (monomialList polynomial)) == 1 + * not (exists constantMonomial (monomialList qpolynomial)) + * (exists realMonomial (monomialList qpolynomial)) + * monomialCoefficient (head (monomialList qpolynomial)) == 1 * - * comparison := TRUE | FALSE | restricted_cmp | (not restricted_cmp) + * integer_restricted_cmp := (|><| zpolynomial constant) + * where + * |><| is GEQ, EQ, or EQ + * not (exists constantMonomial (monomialList zpolynomial)) + * (forall integerMonomial (monomialList qpolynomial)) + * the denominator of all coefficients and the constant is 1 + * the gcd of all numerators of coefficients is 1 + * + * comparison := TRUE | FALSE + * | rational_restricted_cmp | (not rational_restricted_cmp) + * | integer_restricted_cmp | (not integer_restricted_cmp) * * Normal Form for terms := polynomial * Normal Form for atoms := comparison @@ -146,6 +158,11 @@ namespace arith { * * monoOrder m0 m1 = var_listOrder (monomialVarList m0) (monomialVarList m1) * + * integerMonomial mono = + * forall varHasTypeInteger (monomialVarList mono) + * + * realMonomial mono = not (integerMonomial mono) + * * constantMonomial monomial = * match monomial with * constant -> true @@ -193,6 +210,10 @@ public: bool isNormalForm() { return isMember(getNode()); } + bool isIntegral() const { + return getNode().getType().isInteger(); + } + bool operator<(const Variable& v) const { return getNode() < v.getNode();} bool operator==(const Variable& v) const { return getNode() == v.getNode();} @@ -223,7 +244,14 @@ public: return getNode().getConst(); } - bool isZero() const { return getValue() == 0; } + bool isIntegral() const { return getValue().isIntegral(); } + + int sgn() const { return getValue().sgn(); } + + bool isZero() const { return sgn() == 0; } + bool isNegative() const { return sgn() < 0; } + bool isPositive() const { return sgn() > 0; } + bool isOne() const { return getValue() == 1; } Constant operator*(const Constant& other) const { @@ -236,6 +264,33 @@ public: return mkConstant(-getValue()); } + Constant inverse() const{ + Assert(!isZero()); + return mkConstant(getValue().inverse()); + } + + bool operator<(const Constant& other) const { + return getValue() < other.getValue(); + } + + bool operator==(const Constant& other) const { + //Rely on node uniqueness. + return getNode() == other.getNode(); + } + + Constant abs() const { + if(isNegative()){ + return -(*this); + }else{ + return (*this); + } + } + + uint32_t length() const{ + Assert(isIntegral()); + return getValue().getNumerator().length(); + } + };/* class Constant */ @@ -359,6 +414,11 @@ public: return iterator(internalEnd()); } + Variable getHead() const { + Assert(!empty()); + return *(begin()); + } + VarList(Variable v) : NodeWrapper(v.getNode()) { Assert(isSorted(begin(), end())); } @@ -412,6 +472,16 @@ public: bool operator==(const VarList& vl) const { return cmp(vl) == 0; } + bool isIntegral() const { + for(iterator i = begin(), e=end(); i != e; ++i ){ + Variable var = *i; + if(!var.isIntegral()){ + return false; + } + } + return true; + } + private: bool isSorted(iterator start, iterator end); @@ -471,6 +541,9 @@ public: /** Makes a monomial with no restrictions on c and vl. */ static Monomial mkMonomial(const Constant& c, const VarList& vl); + static Monomial mkMonomial(const Variable& v){ + return Monomial(VarList(v)); + } static Monomial parseMonomial(Node n); @@ -495,6 +568,10 @@ public: return constant.isOne(); } + bool absCoefficientIsOne() const { + return coefficientIsOne() || constant.getValue() == -1; + } + Monomial operator*(const Monomial& mono) const; @@ -518,12 +595,41 @@ public: return isSorted(m) && std::adjacent_find(m.begin(),m.end()) == m.end(); } + /** + * The variable product + */ + bool integralVariables() const { + return getVarList().isIntegral(); + } + + /** + * The coefficient of the monomial is integral. + */ + bool integralCoefficient() const { + return getConstant().isIntegral(); + } + + /** + * A Monomial is an "integral" monomial if the constant is integral. + */ + bool isIntegral() const { + return integralCoefficient() && integralVariables(); + } + /** * Given a sorted list of monomials, this function transforms this * into a strictly sorted list of monomials that does not contain zero. */ static std::vector sumLikeTerms(const std::vector& monos); + bool absLessThan(const Monomial& other) const{ + return getConstant().abs() < other.getConstant().abs(); + } + + uint32_t coefficientLength() const{ + return getConstant().length(); + } + void print() const; static void printList(const std::vector& list); @@ -638,6 +744,9 @@ public: Assert( Monomial::isStrictlySorted(m) ); } + static Polynomial mkPolynomial(const Variable& v){ + return Monomial::mkMonomial(v); + } static Polynomial mkPolynomial(const std::vector& m) { if(m.size() == 0) { @@ -696,12 +805,103 @@ public: } } + /** A Polynomial is an "integral" polynomial if all of the monomials are integral. */ + bool allIntegralVariables() const { + for(iterator i = begin(), e=end(); i!=e; ++i){ + if(!(*i).integralVariables()){ + return false; + } + } + return true; + } + + /** + * A Polynomial is an "integral" polynomial if all of the monomials are integral + * and all of the coefficients are Integral. */ + bool isIntegral() const { + for(iterator i = begin(), e=end(); i!=e; ++i){ + if(!(*i).isIntegral()){ + return false; + } + } + return true; + } + + /** + * Selects a minimal monomial in the polynomial by the absolute value of + * the coefficient. + */ + Monomial selectAbsMinimum() const; + + /** + * Returns the Least Common Multiple of the denominators of the coefficients + * of the monomials. + */ + Integer denominatorLCM() const; + + /** + * Returns the GCD of the coefficients of the monomials. + * Requires this to be an isIntegral() polynomial. + */ + Integer gcd() const; + + Polynomial exactDivide(const Integer& z) const { + Assert(isIntegral()); + Constant invz = Constant::mkConstant(Rational(1,z)); + Polynomial prod = (*this) * Monomial(invz); + Assert(prod.isIntegral()); + return prod; + } + Polynomial operator+(const Polynomial& vl) const; Polynomial operator*(const Monomial& mono) const; Polynomial operator*(const Polynomial& poly) const; + /** + * Viewing the integer polynomial as a list [(* coeff_i mono_i)] + * The quotient and remainder of p divided by the non-zero integer z is: + * q := [(* floor(coeff_i/z) mono_i )] + * r := [(* rem(coeff_i/z) mono_i)] + * computeQR(p,z) returns the node (+ q r). + * + * q and r are members of the Polynomial class. + * For example: + * computeQR( p = (+ 5 (* 3 x) (* 8 y)) , z = 2) returns + * (+ (+ 2 x (* 4 y)) (+ 1 x)) + */ + static Node computeQR(const Polynomial& p, const Integer& z); + + /** Returns the coefficient assiociated with the VarList in the polynomial. */ + Constant getCoefficient(const VarList& vl) const; + + uint32_t maxLength() const{ + iterator i = begin(), e=end(); + if( i == e){ + return 1; + }else{ + uint32_t max = (*i).coefficientLength(); + ++i; + for(; i!=e; ++i){ + uint32_t curr = (*i).coefficientLength(); + if(curr > max){ + max = curr; + } + } + return max; + } + } + + uint32_t numMonomials() const { + if( getNode().getKind() == kind::PLUS ){ + return getNode().getNumChildren(); + }else if(isZero()){ + return 0; + }else{ + return 1; + } + } };/* class Polynomial */ @@ -732,6 +932,8 @@ private: */ static bool pbComparison(Kind k, TNode left, const Rational& right, bool& result); + Kind getKind() const { return oper; } + public: Comparison(bool val) : NodeWrapper(NodeManager::currentNM()->mkConst(val)), @@ -750,30 +952,112 @@ public: static Comparison mkComparison(Kind k, const Polynomial& left, const Constant& right); + /** + * Returns the left hand side of the comparison. + * This is a polynomial that always contains all of the variables. + */ + const Polynomial& getLeft() const { return left; } + + /** + * Returns the right hand constatn of the comparison. + * If in normal form, this is the only constant term. + */ + const Constant& getRight() const { return right; } + + /** Returns true if the comparison is a boolean constant. */ bool isBoolean() const { return (oper == kind::CONST_BOOLEAN); } + /** Returns true if all of the variables are integers. */ + bool allIntegralVariables() const { + return getLeft().allIntegralVariables(); + } + + /** + * Returns true if the comparison is either a boolean term, + * in integer normal form or mixed normal form. + */ bool isNormalForm() const { if(isBoolean()) { return true; - } else if(left.containsConstant()) { - return false; - } else if(left.getHead().getConstant().isOne()) { - return true; - } else { - return false; + } else if(allIntegralVariables()) { + return isIntegerNormalForm(); + } else{ + return isMixedNormalForm(); } } - const Polynomial& getLeft() const { return left; } - const Constant& getRight() const { return right; } +private: + /** Normal form check if at least one variable is real. */ + bool isMixedNormalForm() const; + + /** Normal form check is all variables are real.*/ + bool isIntegerNormalForm() const; + +public: + /** + * Returns true if the left hand side is the sum of a non-zero constant + * and a polynomial.*/ + bool constantInLefthand() const; + + /** + * Returns a polynomial that is equivalent to the original but does not contain + * a constant in the top level sum on the left hand side. + */ + Comparison cancelLefthandConstant() const; + + + /** Returns true if the polynomial is a constant. */ + bool isConstant() const; + + /** Reduces a constant comparison to a boolean comaprison.*/ + Comparison evaluateConstant() const; + + + /** + * Returns true if all of the variables are integers, the coefficients are integers, + * and the right hand coefficient is an integer. + */ + bool isIntegral() const; + + /** + * Returns the Least Common Multiple of the monomials + * on the lefthand side and the constant on the right. + */ + Integer denominatorLCM() const; + + /** Multiplies the comparison by the denominatorLCM(). */ + Comparison multiplyByDenominatorLCM() const; + + /** If the leading coefficient is negative, multiply by -1. */ + Comparison normalizeLeadingCoefficientPositive() const; + + /** Divides the Comaprison by the gcd of the lefthand.*/ + Comparison divideByLefthandGCD() const; + + /** Divides the Comparison by the leading coefficient. */ + Comparison divideByLeadingCoefficient() const; + + /** + * If the left hand is integral and the right hand is not, + * the comparison is tightened to the nearest integer. + */ + Comparison tightenIntegralConstraint() const; Comparison addConstant(const Constant& constant) const; + + /* Multiply a non-boolean comparison by a constant term. */ Comparison multiplyConstant(const Constant& constant) const; static Comparison parseNormalForm(TNode n); + /* Returns a logically equivalent comparison in normal form. */ + static Comparison normalize(Comparison c); + + /** Makes a comparison that is in normal form. */ + static Comparison mkNormalComparison(Kind k, const Polynomial& left, const Constant& right); + inline static bool isNormalAtom(TNode n){ Comparison parse = Comparison::parseNormalForm(n); return parse.isNormalForm(); @@ -781,6 +1065,132 @@ public: };/* class Comparison */ +/** + * SumPair is a utility class that extends polynomials for use in computations. + * A SumPair is always a combination of (+ p c) where + * c is a constant and p is a polynomial such that p = 0 or !p.containsConstant(). + * + * These are a useful utility for representing the equation p = c as (+ p -c) where the pair + * is known to implicitly be equal to 0. + * + * SumPairs do not have unique representations due to the potential for p = 0. + * This makes them inappropraite for normal forms. + */ +class SumPair : public NodeWrapper { +private: + static Node toNode(const Polynomial& p, const Constant& c){ + return NodeManager::currentNM()->mkNode(kind::PLUS, p.getNode(), c.getNode()); + } + + SumPair(TNode n) : + NodeWrapper(n) + { + Assert(isNormalForm()); + } + +public: + + SumPair(const Polynomial& p): + NodeWrapper(toNode(p, Constant::mkConstant(0))) + { + Assert(isNormalForm()); + } + + SumPair(const Polynomial& p, const Constant& c): + NodeWrapper(toNode(p, c)) + { + Assert(isNormalForm()); + } + + static bool isMember(TNode n) { + if(n.getKind() == kind::PLUS && n.getNumChildren() == 2){ + if(Constant::isMember(n[1])){ + if(Polynomial::isMember(n[0])){ + Polynomial p = Polynomial::parsePolynomial(n[0]); + return p.isZero() || (!p.containsConstant()); + }else{ + return false; + } + }else{ + return false; + } + }else{ + return false; + } + } + + bool isNormalForm() const { + return isMember(getNode()); + } + + Polynomial getPolynomial() const { + return Polynomial::parsePolynomial(getNode()[0]); + } + + Constant getConstant() const { + return Constant::mkConstant((getNode())[1]); + } + + SumPair operator+(const SumPair& other) const { + return SumPair(getPolynomial() + other.getPolynomial(), + getConstant() + other.getConstant()); + } + + SumPair operator*(const Constant& c) const { + return SumPair(getPolynomial() * c, getConstant() * c); + } + + SumPair operator-(const SumPair& other) const { + return (*this) + (other * Constant::mkConstant(-1)); + } + + static SumPair mkSumPair(const Variable& var){ + return SumPair(Polynomial::mkPolynomial(var)); + } + + static SumPair parseSumPair(TNode n){ + return SumPair(n); + } + + bool isIntegral() const{ + return getConstant().isIntegral() && getPolynomial().isIntegral(); + } + + bool isConstant() const { + return getPolynomial().isZero(); + } + + bool isZero() const { + return getConstant().isZero() && isConstant(); + } + + /** + * Returns the greatest common divisor of gcd(getPolynomial()) and getConstant(). + * The SumPair must be integral. + */ + Integer gcd() const { + Assert(isIntegral()); + return (getPolynomial().gcd()).gcd(getConstant().getValue().getNumerator()); + } + + uint32_t maxLength() const { + Assert(isIntegral()); + return std::max(getPolynomial().maxLength(), getConstant().length()); + } + + static SumPair mkZero() { + return SumPair(Polynomial::mkZero(), Constant::mkConstant(0)); + } + + static Node computeQR(const SumPair& sp, const Integer& div); + + + static SumPair comparisonToSumPair(const Comparison& cmp){ + return SumPair(cmp.getLeft(), - cmp.getRight()); + } + +};/* class SumPair */ + }/* CVC4::theory::arith namespace */ }/* CVC4::theory namespace */ }/* CVC4 namespace */ diff --git a/src/theory/arith/partial_model.cpp b/src/theory/arith/partial_model.cpp index 73f80a70d..4a126ec55 100644 --- a/src/theory/arith/partial_model.cpp +++ b/src/theory/arith/partial_model.cpp @@ -28,6 +28,13 @@ using namespace CVC4::theory; using namespace CVC4::theory::arith; +bool ArithPartialModel::boundsAreEqual(ArithVar x){ + if(hasLowerBound(x) && hasUpperBound(x)){ + return d_upperBound[x] == d_lowerBound[x]; + }else{ + return false; + } +} void ArithPartialModel::zeroDifferenceDetected(ArithVar x){ Assert(d_dm.isDifferenceSlack(x)); diff --git a/src/theory/arith/partial_model.h b/src/theory/arith/partial_model.h index 6e85f7e80..cf0fc7d4e 100644 --- a/src/theory/arith/partial_model.h +++ b/src/theory/arith/partial_model.h @@ -116,7 +116,7 @@ private: void zeroDifferenceDetected(ArithVar x); public: - + bool boundsAreEqual(ArithVar x); void setUpperBound(ArithVar x, const DeltaRational& r); void setLowerBound(ArithVar x, const DeltaRational& r); diff --git a/src/theory/arith/theory_arith.cpp b/src/theory/arith/theory_arith.cpp index ca0763a0c..824bb59ed 100644 --- a/src/theory/arith/theory_arith.cpp +++ b/src/theory/arith/theory_arith.cpp @@ -58,14 +58,17 @@ static const uint32_t RESET_START = 2; TheoryArith::TheoryArith(context::Context* c, context::UserContext* u, OutputChannel& out, Valuation valuation) : Theory(THEORY_ARITH, c, u, out, valuation), + d_hasDoneWorkSinceCut(false), d_atomsInContext(c), d_learner(d_pbSubstitutions), d_nextIntegerCheckVar(0), + d_constantIntegerVariables(c), + d_CivIterator(c,0), + d_varsInDioSolver(c), d_partialModel(c, d_differenceManager), - d_userVariables(), d_diseq(c), d_tableau(), - d_diosolver(c, d_tableau, d_partialModel), + d_diosolver(c), d_pbSubstitutions(u), d_restartsCounter(0), d_rowHasBeenAdded(false), @@ -405,7 +408,7 @@ void TheoryArith::preRegisterTerm(TNode n) { } -ArithVar TheoryArith::requestArithVar(TNode x, bool basic){ +ArithVar TheoryArith::requestArithVar(TNode x, bool slack){ Assert(isLeaf(x) || x.getKind() == PLUS); Assert(!d_arithvarNodeMap.hasArithVar(x)); Assert(x.getType().isReal());// real or integer @@ -413,13 +416,22 @@ ArithVar TheoryArith::requestArithVar(TNode x, bool basic){ ArithVar varX = d_variables.size(); d_variables.push_back(Node(x)); Debug("integers") << "isInteger[[" << x << "]]: " << x.getType().isInteger() << endl; - d_integerVars.push_back(x.getType().isPseudoboolean() ? 2 : (x.getType().isInteger() ? 1 : 0)); + + if(slack){ + //The type computation is not quite accurate for Rationals that are integral. + //We'll use the isIntegral check from the polynomial package instead. + Polynomial p = Polynomial::parsePolynomial(x); + d_variableTypes.push_back(p.isIntegral() ? ATInteger : ATReal); + }else{ + d_variableTypes.push_back(nodeToArithType(x)); + } + + d_slackVars.push_back(slack); d_simplex.increaseMax(); d_arithvarNodeMap.setArithVar(x,varX); - d_userVariables.init(varX, !basic); d_tableau.increaseSize(); Debug("arith::arithvar") << x << " |-> " << varX << endl; @@ -577,11 +589,114 @@ bool TheoryArith::canSafelyAvoidEqualitySetup(TNode equality){ return d_arithvarNodeMap.hasArithVar(equality[0]); } +Comparison TheoryArith::mkIntegerEqualityFromAssignment(ArithVar v){ + const DeltaRational& beta = d_partialModel.getAssignment(v); + + Assert(beta.isIntegral()); + Constant betaAsConstant = Constant::mkConstant(beta.floor()); + + TNode var = d_arithvarNodeMap.asNode(v); + Polynomial varAsPolynomial = Polynomial::parsePolynomial(var); + return Comparison::mkComparison(EQUAL, varAsPolynomial, betaAsConstant); +} + +Node TheoryArith::dioCutting(){ + context::Context::ScopedPush speculativePush(getContext()); + //DO NOT TOUCH THE OUTPUTSTREAM + + //TODO: Improve this + for(ArithVar v = 0, end = d_variables.size(); v != end; ++v){ + if(isInteger(v)){ + const DeltaRational& dr = d_partialModel.getAssignment(v); + if(d_partialModel.equalsUpperBound(v, dr) || d_partialModel.equalsLowerBound(v, dr)){ + if(!d_partialModel.boundsAreEqual(v)){ + // If the bounds are equal this is already in the dioSolver + //Add v = dr as a speculation. + Comparison eq = mkIntegerEqualityFromAssignment(v); + Assert(!eq.isBoolean()); + d_diosolver.pushInputConstraint(eq, eq.getNode()); + // It does not matter what the explanation of eq is. + // It cannot be used in a conflict + } + } + } + } + + SumPair plane = d_diosolver.processEquationsForCut(); + if(plane.isZero()){ + return Node::null(); + }else{ + Polynomial p = plane.getPolynomial(); + Constant c = plane.getConstant() * Constant::mkConstant(-1); + Integer gcd = p.gcd(); + Assert(p.isIntegral()); + Assert(c.isIntegral()); + Assert(gcd > 1); + Assert(!gcd.divides(c.getValue().getNumerator())); + Comparison leq = Comparison::mkComparison(LEQ, p, c); + Comparison geq = Comparison::mkComparison(GEQ, p, c); + Node lemma = NodeManager::currentNM()->mkNode(OR, leq.getNode(), geq.getNode()); + Node rewrittenLemma = Rewriter::rewrite(lemma); + Debug("arith::dio") << "dioCutting found the plane: " << plane.getNode() << endl; + Debug("arith::dio") << "resulting in the cut: " << lemma << endl; + Debug("arith::dio") << "rewritten " << rewrittenLemma << endl; + return rewrittenLemma; + } +} + +Node TheoryArith::callDioSolver(){ + while(d_CivIterator < d_constantIntegerVariables.size()){ + ArithVar v = d_constantIntegerVariables[d_CivIterator]; + d_CivIterator = d_CivIterator + 1; + + Debug("arith::dio") << v << endl; + + Assert(isInteger(v)); + Assert(d_partialModel.boundsAreEqual(v)); + + if(d_varsInDioSolver.find(v) != d_varsInDioSolver.end()){ + continue; + }else{ + d_varsInDioSolver.insert(v); + } + + TNode lb = d_partialModel.getLowerConstraint(v); + TNode ub = d_partialModel.getUpperConstraint(v); + + Node orig = Node::null(); + if(lb == ub){ + Assert(lb.getKind() == EQUAL); + orig = lb; + }else{ + NodeBuilder<> nb(AND); + nb << ub << lb; + orig = nb; + } + + Assert(d_partialModel.assignmentIsConsistent(v)); + + Comparison eq = mkIntegerEqualityFromAssignment(v); + + if(eq.isBoolean()){ + //This can only be a conflict + Assert(!eq.getNode().getConst()); + + //This should be handled by the normal form earlier in the case of equality + Assert(orig.getKind() != EQUAL); + return orig; + }else{ + d_diosolver.pushInputConstraint(eq, orig); + } + } + + return d_diosolver.processEquationsForConflict(); +} + Node TheoryArith::assertionCases(TNode assertion){ - Kind simpKind = simplifiedKind(assertion); - Assert(simpKind != UNDEFINED_KIND); - if(simpKind == EQUAL || simpKind == DISTINCT){ - Node eq = (simpKind == DISTINCT) ? assertion[0] : assertion; + Kind simpleKind = simplifiedKind(assertion); + Assert(simpleKind != UNDEFINED_KIND); + if(simpleKind == EQUAL || simpleKind == DISTINCT){ + Node eq = (simpleKind == DISTINCT) ? assertion[0] : assertion; if(!isSetup(eq)){ //The previous code was equivalent to: @@ -592,35 +707,71 @@ Node TheoryArith::assertionCases(TNode assertion){ } } - ArithVar x_i = determineLeftVariable(assertion, simpKind); - DeltaRational c_i = determineRightConstant(assertion, simpKind); + ArithVar x_i = determineLeftVariable(assertion, simpleKind); + DeltaRational c_i = determineRightConstant(assertion, simpleKind); + + bool tightened = false; + + //If the variable is an integer tighen the constraint. + if(isInteger(x_i)){ + if(simpleKind == LT){ + tightened = true; + c_i = DeltaRational(c_i.floor()); + }else if(simpleKind == GT){ + tightened = true; + c_i = DeltaRational(c_i.ceiling()); + } + } Debug("arith::assertions") << "arith assertion @" << getContext()->getLevel() <<"(" << assertion << " \\-> " - << x_i<<" "<< simpKind <<" "<< c_i << ")" << std::endl; - switch(simpKind){ + << x_i<<" "<< simpleKind <<" "<< c_i << ")" << std::endl; + + switch(simpleKind){ case LEQ: - if (d_partialModel.hasLowerBound(x_i) && d_partialModel.getLowerBound(x_i) == c_i) { - Node diseq = assertion[0].eqNode(assertion[1]).notNode(); - if (d_diseq.find(diseq) != d_diseq.end()) { - Node lb = d_partialModel.getLowerConstraint(x_i); - return disequalityConflict(diseq, lb , assertion); + case LT: + if(simpleKind == LEQ || (simpleKind == LT && tightened)){ + if (d_partialModel.hasLowerBound(x_i) && d_partialModel.getLowerBound(x_i) == c_i) { + //If equal + TNode left = getSide(assertion, simpleKind); + TNode right = getSide(assertion, simpleKind); + + Node diseq = left.eqNode(right).notNode(); + if (d_diseq.find(diseq) != d_diseq.end()) { + Node lb = d_partialModel.getLowerConstraint(x_i); + return disequalityConflict(diseq, lb , assertion); + } + + if(isInteger(x_i)){ + d_constantIntegerVariables.push_back(x_i); + } } } - case LT: return d_simplex.AssertUpper(x_i, c_i, assertion); case GEQ: - if (d_partialModel.hasUpperBound(x_i) && d_partialModel.getUpperBound(x_i) == c_i) { - Node diseq = assertion[0].eqNode(assertion[1]).notNode(); - if (d_diseq.find(diseq) != d_diseq.end()) { - Node ub = d_partialModel.getUpperConstraint(x_i); - return disequalityConflict(diseq, assertion, ub); + case GT: + if(simpleKind == GEQ || (simpleKind == GT && tightened)){ + if (d_partialModel.hasUpperBound(x_i) && d_partialModel.getUpperBound(x_i) == c_i) { + //If equal + TNode left = getSide(assertion, simpleKind); + TNode right = getSide(assertion, simpleKind); + + Node diseq = left.eqNode(right).notNode(); + if (d_diseq.find(diseq) != d_diseq.end()) { + Node ub = d_partialModel.getUpperConstraint(x_i); + return disequalityConflict(diseq, assertion, ub); + } + if(isInteger(x_i)){ + d_constantIntegerVariables.push_back(x_i); + } } } - case GT: return d_simplex.AssertLower(x_i, c_i, assertion); case EQUAL: + if(isInteger(x_i)){ + d_constantIntegerVariables.push_back(x_i); + } return d_simplex.AssertEquality(x_i, c_i, assertion); case DISTINCT: { @@ -649,11 +800,34 @@ Node TheoryArith::assertionCases(TNode assertion){ } } +/** + * Looks for the next integer variable without an integer assignment in a round robin fashion. + * Changes the value of d_nextIntegerCheckVar. + * + * If this returns false, d_nextIntegerCheckVar does not have an integer assignment. + * If this returns true, all integer variables have an integer assignment. + */ +bool TheoryArith::hasIntegerModel(){ + if(d_variables.size() > 0){ + const ArithVar rrEnd = d_nextIntegerCheckVar; + do { + //Do not include slack variables + if(isInteger(d_nextIntegerCheckVar) && !isSlackVariable(d_nextIntegerCheckVar)) { // integer + const DeltaRational& d = d_partialModel.getAssignment(d_nextIntegerCheckVar); + if(!d.isIntegral()){ + return false; + } + } + } while((d_nextIntegerCheckVar = (1 + d_nextIntegerCheckVar == d_variables.size() ? 0 : 1 + d_nextIntegerCheckVar)) != rrEnd); + } + return true; +} void TheoryArith::check(Effort effortLevel){ Debug("arith") << "TheoryArith::check begun" << std::endl; + d_hasDoneWorkSinceCut = d_hasDoneWorkSinceCut || !done(); while(!done()){ Node assertion = get(); @@ -672,6 +846,7 @@ void TheoryArith::check(Effort effortLevel){ debugPrintAssertions(); } + bool emmittedConflictOrSplit = false; Node possibleConflict = d_simplex.updateInconsistentVars(); if(possibleConflict != Node::null()){ d_partialModel.revertAssignmentChanges(); @@ -679,146 +854,184 @@ void TheoryArith::check(Effort effortLevel){ Debug("arith::conflict") << "conflict " << possibleConflict << endl; d_out->conflict(possibleConflict); + emmittedConflictOrSplit = true; }else{ d_partialModel.commitAssignmentChanges(); - - if (fullEffort(effortLevel)) { - splitDisequalities(); - } } - if(fullEffort(effortLevel) && d_integerVars.size() > 0) { - const ArithVar rrEnd = d_nextIntegerCheckVar; - do { - ArithVar v = d_nextIntegerCheckVar; - short type = d_integerVars[v]; - if(type > 0) { // integer - const DeltaRational& d = d_partialModel.getAssignment(v); - const Rational& r = d.getNoninfinitesimalPart(); - const Rational& i = d.getInfinitesimalPart(); - Trace("integers") << "integers: assignment to [[" << d_arithvarNodeMap.asNode(v) << "]] is " << r << "[" << i << "]" << endl; - if(type == 2) { - // pseudoboolean - if(r.getDenominator() == 1 && i.getNumerator() == 0 && - (r.getNumerator() == 0 || r.getNumerator() == 1)) { - // already pseudoboolean; skip - continue; - } + if(!emmittedConflictOrSplit && fullEffort(effortLevel)){ + emmittedConflictOrSplit = splitDisequalities(); + } - TNode var = d_arithvarNodeMap.asNode(v); - Node zero = NodeManager::currentNM()->mkConst(Integer(0)); - Node one = NodeManager::currentNM()->mkConst(Integer(1)); - Node eq0 = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::EQUAL, var, zero)); - Node eq1 = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::EQUAL, var, one)); - Node lem = NodeManager::currentNM()->mkNode(kind::OR, eq0, eq1); - Trace("pb") << "pseudobooleans: branch & bound: " << lem << endl; - Trace("integers") << "pseudobooleans: branch & bound: " << lem << endl; - //d_out->lemma(lem); - } - if(r.getDenominator() == 1 && i.getNumerator() == 0) { - // already an integer assignment; skip - continue; - } + if(!emmittedConflictOrSplit && fullEffort(effortLevel) && !hasIntegerModel()){ - // otherwise, try the Diophantine equation solver - //bool result = d_diosolver.solve(); - //Debug("integers") << "the dio solver returned " << (result ? "true" : "false") << endl; - - // branch and bound - if(r.getDenominator() == 1) { - // r is an integer, but the infinitesimal might not be - if(i.getNumerator() < 0) { - // lemma: v <= r - 1 || v >= r - - TNode var = d_arithvarNodeMap.asNode(v); - Node nrMinus1 = NodeManager::currentNM()->mkConst(r - 1); - Node nr = NodeManager::currentNM()->mkConst(r); - Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, nrMinus1)); - Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, nr)); - - Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); - Trace("integers") << "integers: branch & bound: " << lem << endl; - if(d_valuation.isSatLiteral(lem[0])) { - Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; - } else { - Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; - } - if(d_valuation.isSatLiteral(lem[1])) { - Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; - } else { - Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; - } - ++(d_statistics.d_externalBranchAndBounds); - d_out->lemma(lem); - - // split only on one var - break; - } else if(i.getNumerator() > 0) { - // lemma: v <= r || v >= r + 1 - - TNode var = d_arithvarNodeMap.asNode(v); - Node nr = NodeManager::currentNM()->mkConst(r); - Node nrPlus1 = NodeManager::currentNM()->mkConst(r + 1); - Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, nr)); - Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, nrPlus1)); - - Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); - Trace("integers") << "integers: branch & bound: " << lem << endl; - if(d_valuation.isSatLiteral(lem[0])) { - Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; - } else { - Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; - } - if(d_valuation.isSatLiteral(lem[1])) { - Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; - } else { - Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; - } - ++(d_statistics.d_externalBranchAndBounds); - d_out->lemma(lem); + if(!emmittedConflictOrSplit){ + possibleConflict = callDioSolver(); + if(possibleConflict != Node::null()){ + Debug("arith::conflict") << "dio conflict " << possibleConflict << endl; + d_out->conflict(possibleConflict); + emmittedConflictOrSplit = true; + } + } - // split only on one var - break; - } else { - Unreachable(); - } - } else { - // lemma: v <= floor(r) || v >= ceil(r) - - TNode var = d_arithvarNodeMap.asNode(v); - Node floor = NodeManager::currentNM()->mkConst(r.floor()); - Node ceiling = NodeManager::currentNM()->mkConst(r.ceiling()); - Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, floor)); - Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, ceiling)); - - Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); - Trace("integers") << "integers: branch & bound: " << lem << endl; - if(d_valuation.isSatLiteral(lem[0])) { - Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; - } else { - Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; - } - if(d_valuation.isSatLiteral(lem[1])) { - Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; - } else { - Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; - } - ++(d_statistics.d_externalBranchAndBounds); - d_out->lemma(lem); + if(!emmittedConflictOrSplit && d_hasDoneWorkSinceCut){ + Node possibleLemma = dioCutting(); + if(!possibleLemma.isNull()){ + Debug("arith") << "dio cut " << possibleLemma << endl; + emmittedConflictOrSplit = true; + d_hasDoneWorkSinceCut = false; + d_out->lemma(possibleLemma); + } + } - // split only on one var - break; - } - }// if(arithvar is integer-typed) - } while((d_nextIntegerCheckVar = (1 + d_nextIntegerCheckVar == d_variables.size() ? 0 : 1 + d_nextIntegerCheckVar)) != rrEnd); - }// if(full effort) + if(!emmittedConflictOrSplit) { + Node possibleLemma = roundRobinBranch(); + if(!possibleLemma.isNull()){ + ++(d_statistics.d_externalBranchAndBounds); + emmittedConflictOrSplit = true; + d_out->lemma(possibleLemma); + } + } + }//if !emmittedConflictOrSplit && fullEffort(effortLevel) && !hasIntegerModel() if(Debug.isOn("paranoid:check_tableau")){ d_simplex.debugCheckTableau(); } if(Debug.isOn("arith::print_model")) { debugPrintModel(); } Debug("arith") << "TheoryArith::check end" << std::endl; } -void TheoryArith::splitDisequalities(){ +/** Returns true if the roundRobinBranching() issues a lemma. */ +Node TheoryArith::roundRobinBranch(){ + if(hasIntegerModel()){ + return Node::null(); + }else{ + ArithVar v = d_nextIntegerCheckVar; + + Assert(isInteger(v)); + Assert(!isSlackVariable(v)); + + const DeltaRational& d = d_partialModel.getAssignment(v); + const Rational& r = d.getNoninfinitesimalPart(); + const Rational& i = d.getInfinitesimalPart(); + Trace("integers") << "integers: assignment to [[" << d_arithvarNodeMap.asNode(v) << "]] is " << r << "[" << i << "]" << endl; + + Assert(! (r.getDenominator() == 1 && i.getNumerator() == 0)); + Assert(!d.isIntegral()); + + TNode var = d_arithvarNodeMap.asNode(v); + Integer floor_d = d.floor(); + Integer ceil_d = d.ceiling(); + + Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, mkIntegerNode(floor_d))); + Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, mkIntegerNode(ceil_d))); + + + Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); + Trace("integers") << "integers: branch & bound: " << lem << endl; + if(d_valuation.isSatLiteral(lem[0])) { + Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; + } else { + Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; + } + if(d_valuation.isSatLiteral(lem[1])) { + Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; + } else { + Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; + } + return lem; + + // // branch and bound + // if(r.getDenominator() == 1) { + // // r is an integer, but the infinitesimal might not be + // if(i.getNumerator() < 0) { + // // lemma: v <= r - 1 || v >= r + + // TNode var = d_arithvarNodeMap.asNode(v); + // Node nrMinus1 = NodeManager::currentNM()->mkConst(r - 1); + // Node nr = NodeManager::currentNM()->mkConst(r); + // Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, nrMinus1)); + // Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, nr)); + + // Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); + // Trace("integers") << "integers: branch & bound: " << lem << endl; + // if(d_valuation.isSatLiteral(lem[0])) { + // Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; + // } else { + // Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; + // } + // if(d_valuation.isSatLiteral(lem[1])) { + // Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; + // } else { + // Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; + // } + // return lem; + // } else if(i.getNumerator() > 0) { + // // lemma: v <= r || v >= r + 1 + + // TNode var = d_arithvarNodeMap.asNode(v); + // Node nr = NodeManager::currentNM()->mkConst(r); + // Node nrPlus1 = NodeManager::currentNM()->mkConst(r + 1); + // Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, nr)); + // Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, nrPlus1)); + + // Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); + // Trace("integers") << "integers: branch & bound: " << lem << endl; + // if(d_valuation.isSatLiteral(lem[0])) { + // Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; + // } else { + // Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; + // } + // if(d_valuation.isSatLiteral(lem[1])) { + // Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; + // } else { + // Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; + // } + // ++(d_statistics.d_externalBranchAndBounds); + // d_out->lemma(lem); + // result = true; + + // // split only on one var + // break; + // } else { + // Unreachable(); + // } + // } else { + // // lemma: v <= floor(r) || v >= ceil(r) + + // TNode var = d_arithvarNodeMap.asNode(v); + // Node floor = NodeManager::currentNM()->mkConst(r.floor()); + // Node ceiling = NodeManager::currentNM()->mkConst(r.ceiling()); + // Node leq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::LEQ, var, floor)); + // Node geq = Rewriter::rewrite(NodeManager::currentNM()->mkNode(kind::GEQ, var, ceiling)); + + // Node lem = NodeManager::currentNM()->mkNode(kind::OR, leq, geq); + // Trace("integers") << "integers: branch & bound: " << lem << endl; + // if(d_valuation.isSatLiteral(lem[0])) { + // Debug("integers") << " " << lem[0] << " == " << d_valuation.getSatValue(lem[0]) << endl; + // } else { + // Debug("integers") << " " << lem[0] << " is not assigned a SAT literal" << endl; + // } + // if(d_valuation.isSatLiteral(lem[1])) { + // Debug("integers") << " " << lem[1] << " == " << d_valuation.getSatValue(lem[1]) << endl; + // } else { + // Debug("integers") << " " << lem[1] << " is not assigned a SAT literal" << endl; + // } + // ++(d_statistics.d_externalBranchAndBounds); + // d_out->lemma(lem); + // result = true; + + // // split only on one var + // break; + // } + // }// if(arithvar is integer-typed) + // } while((d_nextIntegerCheckVar = (1 + d_nextIntegerCheckVar == d_variables.size() ? 0 : 1 + d_nextIntegerCheckVar)) != rrEnd); + + // return result; + } +} + +bool TheoryArith::splitDisequalities(){ + bool splitSomething = false; + context::CDSet::iterator it = d_diseq.begin(); context::CDSet::iterator it_end = d_diseq.end(); for(; it != it_end; ++ it) { @@ -839,8 +1052,10 @@ void TheoryArith::splitDisequalities(){ Node lemma = NodeBuilder<3>(OR) << eq << ltNode << gtNode; ++(d_statistics.d_statDisequalitySplits); d_out->lemma(lemma); + splitSomething = true; } } + return splitSomething; } /** @@ -852,12 +1067,12 @@ void TheoryArith::debugPrintAssertions() { for (ArithVar i = 0; i < d_variables.size(); ++ i) { if (d_partialModel.hasLowerBound(i)) { Node lConstr = d_partialModel.getLowerConstraint(i); - Debug("arith::print_assertions") << lConstr.toString() << endl; + Debug("arith::print_assertions") << lConstr << endl; } if (d_partialModel.hasUpperBound(i)) { Node uConstr = d_partialModel.getUpperConstraint(i); - Debug("arith::print_assertions") << uConstr.toString() << endl; + Debug("arith::print_assertions") << uConstr << endl; } } context::CDSet::iterator it = d_diseq.begin(); @@ -1162,7 +1377,7 @@ void TheoryArith::presolve(){ for(VarIter i = d_variables.begin(), end = d_variables.end(); i != end; ++i){ Node variableNode = *i; ArithVar var = d_arithvarNodeMap.asArithVar(variableNode); - if(d_userVariables.isMember(var) && + if(!isSlackVariable(var) && !d_atomDatabase.hasAnyAtoms(variableNode) && !variableNode.getType().isInteger()){ //The user variable is unconstrained. diff --git a/src/theory/arith/theory_arith.h b/src/theory/arith/theory_arith.h index 6255efbbc..6b14ae6ff 100644 --- a/src/theory/arith/theory_arith.h +++ b/src/theory/arith/theory_arith.h @@ -12,8 +12,7 @@ ** information.\endverbatim ** ** \brief Arithmetic theory. - ** - ** Arithmetic theory. + ** ** Arithmetic theory. **/ #include "cvc4_private.h" @@ -59,6 +58,8 @@ namespace arith { class TheoryArith : public Theory { private: + bool d_hasDoneWorkSinceCut; + /** * The set of atoms that are currently in the context. * This is exactly the union of preregistered atoms and @@ -108,10 +109,40 @@ private: /** - * List of the types of variables in the system. - * "True" means integer, "false" means (non-integer) real. + * (For the moment) the type hierarchy goes as: + * PsuedoBoolean <: Integer <: Real + * The type number of a variable is an integer representing the most specific + * type of the variable. The possible values of type number are: */ - std::vector d_integerVars; + enum ArithType + { + ATReal = 0, + ATInteger = 1, + ATPsuedoBoolean = 2 + }; + + std::vector d_variableTypes; + inline ArithType nodeToArithType(TNode x) const { + return x.getType().isPseudoboolean() ? ATPsuedoBoolean : + (x.getType().isInteger() ? ATInteger : ATReal); + } + + /** Returns true if x is of type Integer or PsuedoBoolean. */ + inline bool isInteger(ArithVar x) const { + return d_variableTypes[x] >= ATInteger; + } + /** Returns true if x is of type PsuedoBoolean. */ + inline bool isPsuedoBoolean(ArithVar x) const { + return d_variableTypes[x] == ATPsuedoBoolean; + } + + /** This is the set of variables initially introduced as slack variables. */ + std::vector d_slackVars; + + /** Returns true if the variable was initially introduced as a slack variable. */ + inline bool isSlackVariable(ArithVar x) const{ + return d_slackVars[x]; + } /** * On full effort checks (after determining LA(Q) satisfiability), we @@ -122,6 +153,21 @@ private: */ ArithVar d_nextIntegerCheckVar; + /** + * Queue of Integer variables that are known to be equal to a constant. + */ + context::CDList d_constantIntegerVariables; + /** Iterator over d_constantIntegerVariables. */ + context::CDO d_CivIterator; + + Node callDioSolver(); + Node dioCutting(); + + Comparison mkIntegerEqualityFromAssignment(ArithVar v); + + #warning "DO NOT COMMIT TO TRUNK, USE MORE EFFICIENT CHECK INSTEAD" + CDArithVarSet d_varsInDioSolver; + /** * If ArithVar v maps to the node n in d_removednode, * then n = (= asNode(v) rhs) where rhs is a term that @@ -135,11 +181,6 @@ private: */ ArithPartialModel d_partialModel; - /** - * Set of ArithVars that were introduced via preregisteration. - */ - ArithVarSet d_userVariables; - /** * List of all of the inequalities asserted in the current context. */ @@ -246,15 +287,37 @@ private: */ ArithVar determineLeftVariable(TNode assertion, Kind simpleKind); - /** Splits the disequalities in d_diseq that are violated using lemmas on demand. */ - void splitDisequalities(); + /** + * Splits the disequalities in d_diseq that are violated using lemmas on demand. + * returns true if any lemmas were issued. + * returns false if all disequalities are satisified in the current model. + */ + bool splitDisequalities(); + + + + /** + * Looks for the next integer variable without an integer assignment in a round robin fashion. + * Changes the value of d_nextIntegerCheckVar. + * + * If this returns false, d_nextIntegerCheckVar does not have an integer assignment. + * If this returns true, all integer variables have an integer assignment. + */ + bool hasIntegerModel(); + + /** + * Issues branches for non-slack integer variables with non-integer assignments. + * Returns a cut for a lemma. + * If there is an integer model, this returns Node::null(). + */ + Node roundRobinBranch(); /** * This requests a new unique ArithVar value for x. * This also does initial (not context dependent) set up for a variable, * except for setting up the initial. */ - ArithVar requestArithVar(TNode x, bool basic); + ArithVar requestArithVar(TNode x, bool slack); /** Initial (not context dependent) sets up for a variable.*/ void setupInitialValue(ArithVar x); diff --git a/src/util/bitvector.h b/src/util/bitvector.h index f05ebaf17..d7f0e13a5 100644 --- a/src/util/bitvector.h +++ b/src/util/bitvector.h @@ -91,15 +91,18 @@ public: } BitVector operator ~() const { + //is this right? it looks like a no-op? return BitVector(d_size, d_value); } BitVector concat (const BitVector& other) const { - return BitVector(d_size + other.d_size, (d_value * Integer(2).pow(other.d_size)) + other.d_value); + return BitVector(d_size + other.d_size, (d_value.multiplyByPow2(other.d_size)) + other.d_value); + //return BitVector(d_size + other.d_size, (d_value * Integer(2).pow(other.d_size)) + other.d_value); } BitVector extract(unsigned high, unsigned low) const { - return BitVector(high - low + 1, (d_value % (Integer(2).pow(high + 1))) / Integer(2).pow(low)); + return BitVector(high - low + 1, d_value.extractBitRange(high - low + 1, low)); + //return BitVector(high - low + 1, (d_value % (Integer(2).pow(high + 1))) / Integer(2).pow(low)); } size_t hash() const { diff --git a/src/util/integer_cln_imp.h b/src/util/integer_cln_imp.h index f8ffc0d65..06459e3e1 100644 --- a/src/util/integer_cln_imp.h +++ b/src/util/integer_cln_imp.h @@ -167,6 +167,7 @@ public: return *this; } + /* Integer operator/(const Integer& y) const { return Integer( cln::floor1(d_value, y.d_value) ); } @@ -182,6 +183,65 @@ public: d_value = cln::floor2(d_value, y.d_value).remainder; return *this; } + */ + + /** + * Return this*(2^pow). + */ + Integer multiplyByPow2(uint32_t pow) const { + cln::cl_I ipow(pow); + return Integer( d_value << ipow); + } + + /** See CLN Documentation. */ + Integer extractBitRange(uint32_t bitCount, uint32_t low) const { + cln::cl_byte range(bitCount, low); + return Integer(cln::ldb(d_value, range)); + } + + /** + * Returns the floor(this / y) + */ + Integer floorDivideQuotient(const Integer& y) const { + return Integer( cln::floor1(d_value, y.d_value) ); + } + + /** + * Returns r == this - floor(this/y)*y + */ + Integer floorDivideRemainder(const Integer& y) const { + return Integer( cln::floor2(d_value, y.d_value).remainder ); + } + /** + * Computes a floor quoient and remainder for x divided by y. + */ + static void floorQR(Integer& q, Integer& r, const Integer& x, const Integer& y) { + cln::cl_I_div_t res = cln::floor2(x.d_value, y.d_value); + q.d_value = res.quotient; + r.d_value = res.remainder; + } + + /** + * Returns the ceil(this / y) + */ + Integer ceilingDivideQuotient(const Integer& y) const { + return Integer( cln::ceiling1(d_value, y.d_value) ); + } + + /** + * Returns the ceil(this / y) + */ + Integer ceilingDivideRemainder(const Integer& y) const { + return Integer( cln::ceiling2(d_value, y.d_value).remainder ); + } + + /** + * If y divides *this, then exactQuotient returns (this/y) + */ + Integer exactQuotient(const Integer& y) const { + Assert(y.divides(*this)); + return Integer( cln::exquo(d_value, y.d_value) ); + } /** * Raise this Integer to the power exp. @@ -207,6 +267,22 @@ public: return Integer(result); } + /** + * Return the least common multiple of this integer with another. + */ + Integer lcm(const Integer& y) const { + cln::cl_I result = cln::lcm(d_value, y.d_value); + return Integer(result); + } + + /** + * Return true if *this exactly divides y. + */ + bool divides(const Integer& y) const { + cln::cl_I result = cln::rem(y.d_value, d_value); + return cln::zerop(result); + } + /** * Return the absolute value of this integer. */ @@ -243,6 +319,12 @@ public: return output; } + int sgn() const { + cln::cl_I sgn = cln::signum(d_value); + Assert(sgn == 0 || sgn == -1 || sgn == 1); + return cln::cl_I_to_int(sgn); + } + //friend std::ostream& operator<<(std::ostream& os, const Integer& n); long getLong() const { @@ -281,6 +363,27 @@ public: return cln::logbitp(n, d_value); } + /** + * If x != 0, returns the unique n s.t. 2^{n-1} <= abs(x) < 2^{n}. + * If x == 0, returns 1. + */ + size_t length() const { + int s = sgn(); + if(s == 0){ + return 1; + }else if(s < 0){ + return cln::integer_length(-d_value); + }else{ + return cln::integer_length(d_value); + } + } + +/* cl_I xgcd (const cl_I& a, const cl_I& b, cl_I* u, cl_I* v) */ +/* This function ("extended gcd") returns the greatest common divisor g of a and b and at the same time the representation of g as an integral linear combination of a and b: u and v with u*a+v*b = g, g >= 0. u and v will be normalized to be of smallest possible absolute value, in the following sense: If a and b are non-zero, and abs(a) != abs(b), u and v will satisfy the inequalities abs(u) <= abs(b)/(2*g), abs(v) <= abs(a)/(2*g). */ + static void extendedGcd(Integer& g, Integer& s, Integer& t, const Integer& a, const Integer& b){ + g.d_value = cln::xgcd(a.d_value, b.d_value, &s.d_value, &t.d_value); + } + friend class CVC4::Rational; };/* class Integer */ diff --git a/src/util/integer_gmp_imp.h b/src/util/integer_gmp_imp.h index 16ca8313b..161666df5 100644 --- a/src/util/integer_gmp_imp.h +++ b/src/util/integer_gmp_imp.h @@ -135,20 +135,82 @@ public: return *this; } - Integer operator/(const Integer& y) const { - return Integer( d_value / y.d_value ); + /** + * Return this*(2^pow). + */ + Integer multiplyByPow2(uint32_t pow) const{ + mpz_class result; + mpz_mul_2exp(result.get_mpz_t(), d_value.get_mpz_t(), pow); + return Integer( result ); } - Integer& operator/=(const Integer& y) { - d_value /= y.d_value; - return *this; + + /** See GMP Documentation. */ + Integer extractBitRange(uint32_t bitCount, uint32_t low) const { + // bitCount = high-low+1 + uint32_t high = low + bitCount-1; + //— Function: void mpz_fdiv_r_2exp (mpz_t r, mpz_t n, mp_bitcnt_t b) + mpz_class rem, div; + mpz_fdiv_r_2exp(rem.get_mpz_t(), d_value.get_mpz_t(), high+1); + mpz_fdiv_q_2exp(div.get_mpz_t(), rem.get_mpz_t(), low); + + return Integer(div); } - Integer operator%(const Integer& y) const { - return Integer( d_value % y.d_value ); + /** + * Returns the floor(this / y) + */ + Integer floorDivideQuotient(const Integer& y) const { + mpz_class q; + mpz_fdiv_q(q.get_mpz_t(), d_value.get_mpz_t(), y.d_value.get_mpz_t()); + return Integer( q ); } - Integer& operator%=(const Integer& y) { - d_value %= y.d_value; - return *this; + + /** + * Returns r == this - floor(this/y)*y + */ + Integer floorDivideRemainder(const Integer& y) const { + mpz_class r; + mpz_fdiv_r(r.get_mpz_t(), d_value.get_mpz_t(), y.d_value.get_mpz_t()); + return Integer( r ); + } + + /** + * Computes a floor quoient and remainder for x divided by y. + */ + static void floorQR(Integer& q, Integer& r, const Integer& x, const Integer& y) { + mpz_fdiv_qr(q.d_value.get_mpz_t(), r.d_value.get_mpz_t(), x.d_value.get_mpz_t(), y.d_value.get_mpz_t()); + } + + /** + * Returns the ceil(this / y) + */ + Integer ceilingDivideQuotient(const Integer& y) const { + mpz_class q; + mpz_cdiv_q(q.get_mpz_t(), d_value.get_mpz_t(), y.d_value.get_mpz_t()); + return Integer( q ); + } + + /** + * Returns the ceil(this / y) + */ + Integer ceilingDivideRemainder(const Integer& y) const { + mpz_class r; + mpz_cdiv_r(r.get_mpz_t(), d_value.get_mpz_t(), y.d_value.get_mpz_t()); + return Integer( r ); + } + + /** + * If y divides *this, then exactQuotient returns (this/y) + */ + Integer exactQuotient(const Integer& y) const { + Assert(y.divides(*this)); + mpz_class q; + mpz_divexact(q.get_mpz_t(), d_value.get_mpz_t(), y.d_value.get_mpz_t()); + return Integer( q ); + } + + int sgn() const { + return mpz_sgn(d_value.get_mpz_t()); } /** @@ -171,6 +233,24 @@ public: return Integer(result); } + /** + * Return the least common multiple of this integer with another. + */ + Integer lcm(const Integer& y) const { + mpz_class result; + mpz_lcm(result.get_mpz_t(), d_value.get_mpz_t(), y.d_value.get_mpz_t()); + return Integer(result); + } + + /** + * All non-zero integers z, z.divide(0) + * ! zero.divides(zero) + */ + bool divides(const Integer& y) const { + int res = mpz_divisible_p(y.d_value.get_mpz_t(), d_value.get_mpz_t()); + return res != 0; + } + /** * Return the absolute value of this integer. */ @@ -217,6 +297,24 @@ public: return mpz_tstbit(d_value.get_mpz_t(), n); } + /** + * If x != 0, returns the smallest n s.t. 2^{n-1} <= abs(x) < 2^{n}. + * If x == 0, returns 1. + */ + size_t length() const { + if(sgn() == 0){ + return 1; + }else{ + return mpz_sizeinbase(d_value.get_mpz_t(),2); + } + } + + static void extendedGcd(Integer& g, Integer& s, Integer& t, const Integer& a, const Integer& b){ + //mpz_gcdext (mpz_t g, mpz_t s, mpz_t t, mpz_t a, mpz_t b); + mpz_gcdext (g.d_value.get_mpz_t(), s.d_value.get_mpz_t(), t.d_value.get_mpz_t(), a.d_value.get_mpz_t(), b.d_value.get_mpz_t()); + } + + friend class CVC4::Rational; };/* class Integer */ diff --git a/src/util/rational_cln_imp.h b/src/util/rational_cln_imp.h index 2f2c14ed8..885e6b628 100644 --- a/src/util/rational_cln_imp.h +++ b/src/util/rational_cln_imp.h @@ -192,6 +192,18 @@ public: } } + Rational abs() const { + if(sgn() < 0){ + return -(*this); + }else{ + return *this; + } + } + + bool isIntegral() const{ + return getDenominator() == 1; + } + Integer floor() const { return Integer(cln::floor1(d_value)); } diff --git a/src/util/rational_gmp_imp.h b/src/util/rational_gmp_imp.h index 37c3c8364..4635ce881 100644 --- a/src/util/rational_gmp_imp.h +++ b/src/util/rational_gmp_imp.h @@ -169,6 +169,14 @@ public: return mpq_sgn(d_value.get_mpq_t()); } + Rational abs() const { + if(sgn() < 0){ + return -(*this); + }else{ + return *this; + } + } + Integer floor() const { mpz_class q; mpz_fdiv_q(q.get_mpz_t(), d_value.get_num_mpz_t(), d_value.get_den_mpz_t()); @@ -244,6 +252,10 @@ public: return (*this); } + bool isIntegral() const{ + return getDenominator() == 1; + } + /** Returns a string representing the rational in the given base. */ std::string toString(int base = 10) const { return d_value.get_str(base); diff --git a/test/regress/regress0/Makefile.am b/test/regress/regress0/Makefile.am index 1a41922ca..27ebac603 100644 --- a/test/regress/regress0/Makefile.am +++ b/test/regress/regress0/Makefile.am @@ -40,7 +40,6 @@ SMT2_TESTS = \ ite4.smt2 \ simple-lra.smt2 \ simple-rdl.smt2 \ - simple-rdl-definefun.smt2 \ simple-uf.smt2 # Regression tests for PL inputs @@ -101,6 +100,8 @@ TESTS = $(SMT_TESTS) $(SMT2_TESTS) $(CVC_TESTS) $(BUG_TESTS) EXTRA_DIST = $(TESTS) \ bug216.smt2 \ bug216.smt2.expect \ + bug288b.smt \ + bug288c.smt \ bug288.smt if CVC4_BUILD_PROFILE_COMPETITION diff --git a/test/regress/regress0/bug288b.smt b/test/regress/regress0/bug288b.smt new file mode 100644 index 000000000..659c90a0f --- /dev/null +++ b/test/regress/regress0/bug288b.smt @@ -0,0 +1,8 @@ +(benchmark delta +:logic QF_LIA +:extrafuns ((x Int)) +:extrafuns ((y Int)) +:status sat +:formula + (>= (* 2 (- x y)) 1) +) diff --git a/test/regress/regress0/bug288c.smt b/test/regress/regress0/bug288c.smt new file mode 100644 index 000000000..acf40ce07 --- /dev/null +++ b/test/regress/regress0/bug288c.smt @@ -0,0 +1,9 @@ +(benchmark delta +:logic QF_LIA +:extrafuns ((x Int)) +:extrafuns ((y Int)) +:extrafuns ((z Int)) +:status sat +:formula + (and (= z 0) (>= (+ (- (* 2 x) (* 2 y)) z) 1)) +) diff --git a/test/regress/regress1/arith/Makefile.am b/test/regress/regress1/arith/Makefile.am index 53aff2491..046efe65f 100644 --- a/test/regress/regress1/arith/Makefile.am +++ b/test/regress/regress1/arith/Makefile.am @@ -12,7 +12,9 @@ TESTS = \ pursuit-safety-11.smt \ pursuit-safety-12.smt \ sc-7.base.cvc.smt \ - uart-8.base.cvc.smt + uart-8.base.cvc.smt \ + qlock-4-10-9.base.cvc.smt2 \ + lpsat-goal-9.smt2 EXTRA_DIST = $(TESTS) diff --git a/test/regress/regress1/arith/lpsat-goal-9.smt2 b/test/regress/regress1/arith/lpsat-goal-9.smt2 new file mode 100644 index 000000000..d71fc1340 --- /dev/null +++ b/test/regress/regress1/arith/lpsat-goal-9.smt2 @@ -0,0 +1,557 @@ +(set-logic QF_IDL) +(set-info :source | +Queuing lock algorithm by Kazuhiro Ogata (ogata@jaist.ac.jp). +Translated into CVC format by Leonardo de Moura. + +This benchmark was automatically translated into SMT-LIB format from +CVC format using CVC Lite + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun cvclZero () Int) +(declare-fun x_0 () Bool) +(declare-fun x_1 () Bool) +(declare-fun x_2 () Bool) +(declare-fun x_3 () Bool) +(declare-fun x_4 () Bool) +(declare-fun x_5 () Bool) +(declare-fun x_6 () Bool) +(declare-fun x_7 () Bool) +(declare-fun x_8 () Bool) +(declare-fun x_9 () Bool) +(declare-fun x_10 () Bool) +(declare-fun x_11 () Bool) +(declare-fun x_12 () Bool) +(declare-fun x_13 () Bool) +(declare-fun x_14 () Bool) +(declare-fun x_15 () Bool) +(declare-fun x_16 () Bool) +(declare-fun x_17 () Bool) +(declare-fun x_18 () Bool) +(declare-fun x_19 () Bool) +(declare-fun x_20 () Bool) +(declare-fun x_21 () Bool) +(declare-fun x_22 () Bool) +(declare-fun x_23 () Bool) +(declare-fun x_24 () Bool) +(declare-fun x_25 () Bool) +(declare-fun x_26 () Bool) +(declare-fun x_27 () Bool) +(declare-fun x_28 () Bool) +(declare-fun x_29 () Bool) +(declare-fun x_30 () Bool) +(declare-fun x_31 () Bool) +(declare-fun x_32 () Int) +(declare-fun x_33 () Int) +(declare-fun x_34 () Int) +(declare-fun x_35 () Int) +(declare-fun x_36 () Int) +(declare-fun x_37 () Int) +(declare-fun x_38 () Int) +(declare-fun x_39 () Int) +(declare-fun x_40 () Int) +(declare-fun x_41 () Int) +(declare-fun x_42 () Int) +(declare-fun x_43 () Int) +(declare-fun x_44 () Int) +(declare-fun x_45 () Int) +(declare-fun x_46 () Int) +(declare-fun x_47 () Int) +(declare-fun x_48 () Bool) +(declare-fun x_49 () Bool) +(declare-fun x_50 () Bool) +(declare-fun x_51 () Bool) +(declare-fun x_52 () Bool) +(declare-fun x_53 () Bool) +(declare-fun x_54 () Bool) +(declare-fun x_55 () Bool) +(declare-fun x_56 () Int) +(declare-fun x_57 () Int) +(declare-fun x_58 () Int) +(declare-fun x_59 () Int) +(declare-fun x_60 () Int) +(declare-fun x_61 () Int) +(declare-fun x_62 () Int) +(declare-fun x_63 () Int) +(declare-fun x_64 () Int) +(declare-fun x_65 () Int) +(declare-fun x_66 () Int) +(declare-fun x_67 () Int) +(declare-fun x_68 () Bool) +(declare-fun x_69 () Bool) +(declare-fun x_70 () Bool) +(declare-fun x_71 () Bool) +(declare-fun x_72 () Bool) +(declare-fun x_73 () Bool) +(declare-fun x_74 () Bool) +(declare-fun x_75 () Bool) +(declare-fun x_76 () Int) +(declare-fun x_77 () Int) +(declare-fun x_78 () Int) +(declare-fun x_79 () Bool) +(declare-fun x_80 () Bool) +(declare-fun x_81 () Bool) +(declare-fun x_82 () Bool) +(declare-fun x_83 () Bool) +(declare-fun x_84 () Bool) +(declare-fun x_85 () Bool) +(declare-fun x_86 () Bool) +(declare-fun x_87 () Bool) +(declare-fun x_88 () Bool) +(declare-fun x_89 () Bool) +(declare-fun x_90 () Bool) +(declare-fun x_91 () Bool) +(declare-fun x_92 () Bool) +(declare-fun x_93 () Bool) +(declare-fun x_94 () Bool) +(declare-fun x_95 () Int) +(declare-fun x_96 () Int) +(declare-fun x_97 () Int) +(declare-fun x_98 () Int) +(declare-fun x_99 () Int) +(declare-fun x_100 () Int) +(declare-fun x_101 () Int) +(declare-fun x_102 () Int) +(declare-fun x_103 () Bool) +(declare-fun x_104 () Bool) +(declare-fun x_105 () Bool) +(declare-fun x_106 () Bool) +(declare-fun x_107 () Bool) +(declare-fun x_108 () Bool) +(declare-fun x_109 () Bool) +(declare-fun x_110 () Bool) +(declare-fun x_111 () Int) +(declare-fun x_112 () Int) +(declare-fun x_113 () Int) +(declare-fun x_114 () Int) +(declare-fun x_115 () Int) +(declare-fun x_116 () Int) +(declare-fun x_117 () Int) +(declare-fun x_118 () Int) +(declare-fun x_119 () Int) +(declare-fun x_120 () Int) +(declare-fun x_121 () Int) +(declare-fun x_122 () Int) +(declare-fun x_123 () Bool) +(declare-fun x_124 () Bool) +(declare-fun x_125 () Bool) +(declare-fun x_126 () Bool) +(declare-fun x_127 () Bool) +(declare-fun x_128 () Bool) +(declare-fun x_129 () Bool) +(declare-fun x_130 () Bool) +(declare-fun x_131 () Int) +(declare-fun x_132 () Int) +(declare-fun x_133 () Int) +(declare-fun x_134 () Bool) +(declare-fun x_135 () Bool) +(declare-fun x_136 () Bool) +(declare-fun x_137 () Bool) +(declare-fun x_138 () Bool) +(declare-fun x_139 () Bool) +(declare-fun x_140 () Bool) +(declare-fun x_141 () Bool) +(declare-fun x_142 () Bool) +(declare-fun x_143 () Bool) +(declare-fun x_144 () Bool) +(declare-fun x_145 () Bool) +(declare-fun x_146 () Bool) +(declare-fun x_147 () Bool) +(declare-fun x_148 () Bool) +(declare-fun x_149 () Bool) +(declare-fun x_150 () Int) +(declare-fun x_151 () Int) +(declare-fun x_152 () Int) +(declare-fun x_153 () Int) +(declare-fun x_154 () Int) +(declare-fun x_155 () Int) +(declare-fun x_156 () Int) +(declare-fun x_157 () Int) +(declare-fun x_158 () Bool) +(declare-fun x_159 () Bool) +(declare-fun x_160 () Bool) +(declare-fun x_161 () Bool) +(declare-fun x_162 () Bool) +(declare-fun x_163 () Bool) +(declare-fun x_164 () Bool) +(declare-fun x_165 () Bool) +(declare-fun x_166 () Int) +(declare-fun x_167 () Int) +(declare-fun x_168 () Int) +(declare-fun x_169 () Int) +(declare-fun x_170 () Int) +(declare-fun x_171 () Int) +(declare-fun x_172 () Int) +(declare-fun x_173 () Int) +(declare-fun x_174 () Int) +(declare-fun x_175 () Int) +(declare-fun x_176 () Int) +(declare-fun x_177 () Int) +(declare-fun x_178 () Bool) +(declare-fun x_179 () Bool) +(declare-fun x_180 () Bool) +(declare-fun x_181 () Bool) +(declare-fun x_182 () Bool) +(declare-fun x_183 () Bool) +(declare-fun x_184 () Bool) +(declare-fun x_185 () Bool) +(declare-fun x_186 () Int) +(declare-fun x_187 () Int) +(declare-fun x_188 () Int) +(declare-fun x_189 () Bool) +(declare-fun x_190 () Bool) +(declare-fun x_191 () Bool) +(declare-fun x_192 () Bool) +(declare-fun x_193 () Bool) +(declare-fun x_194 () Bool) +(declare-fun x_195 () Bool) +(declare-fun x_196 () Bool) +(declare-fun x_197 () Bool) +(declare-fun x_198 () Bool) +(declare-fun x_199 () Bool) +(declare-fun x_200 () Bool) +(declare-fun x_201 () Bool) +(declare-fun x_202 () Bool) +(declare-fun x_203 () Bool) +(declare-fun x_204 () Bool) +(declare-fun x_205 () Int) +(declare-fun x_206 () Int) +(declare-fun x_207 () Int) +(declare-fun x_208 () Int) +(declare-fun x_209 () Int) +(declare-fun x_210 () Int) +(declare-fun x_211 () Int) +(declare-fun x_212 () Int) +(declare-fun x_213 () Bool) +(declare-fun x_214 () Bool) +(declare-fun x_215 () Bool) +(declare-fun x_216 () Bool) +(declare-fun x_217 () Bool) +(declare-fun x_218 () Bool) +(declare-fun x_219 () Bool) +(declare-fun x_220 () Bool) +(declare-fun x_221 () Int) +(declare-fun x_222 () Int) +(declare-fun x_223 () Int) +(declare-fun x_224 () Int) +(declare-fun x_225 () Int) +(declare-fun x_226 () Int) +(declare-fun x_227 () Int) +(declare-fun x_228 () Int) +(declare-fun x_229 () Int) +(declare-fun x_230 () Int) +(declare-fun x_231 () Int) +(declare-fun x_232 () Int) +(declare-fun x_233 () Bool) +(declare-fun x_234 () Bool) +(declare-fun x_235 () Bool) +(declare-fun x_236 () Bool) +(declare-fun x_237 () Bool) +(declare-fun x_238 () Bool) +(declare-fun x_239 () Bool) +(declare-fun x_240 () Bool) +(declare-fun x_241 () Int) +(declare-fun x_242 () Int) +(declare-fun x_243 () Int) +(declare-fun x_244 () Bool) +(declare-fun x_245 () Bool) +(declare-fun x_246 () Bool) +(declare-fun x_247 () Bool) +(declare-fun x_248 () Bool) +(declare-fun x_249 () Bool) +(declare-fun x_250 () Bool) +(declare-fun x_251 () Bool) +(declare-fun x_252 () Bool) +(declare-fun x_253 () Bool) +(declare-fun x_254 () Bool) +(declare-fun x_255 () Bool) +(declare-fun x_256 () Bool) +(declare-fun x_257 () Bool) +(declare-fun x_258 () Bool) +(declare-fun x_259 () Bool) +(declare-fun x_260 () Int) +(declare-fun x_261 () Int) +(declare-fun x_262 () Int) +(declare-fun x_263 () Int) +(declare-fun x_264 () Int) +(declare-fun x_265 () Int) +(declare-fun x_266 () Int) +(declare-fun x_267 () Int) +(declare-fun x_268 () Bool) +(declare-fun x_269 () Bool) +(declare-fun x_270 () Bool) +(declare-fun x_271 () Bool) +(declare-fun x_272 () Bool) +(declare-fun x_273 () Bool) +(declare-fun x_274 () Bool) +(declare-fun x_275 () Bool) +(declare-fun x_276 () Int) +(declare-fun x_277 () Int) +(declare-fun x_278 () Int) +(declare-fun x_279 () Int) +(declare-fun x_280 () Int) +(declare-fun x_281 () Int) +(declare-fun x_282 () Int) +(declare-fun x_283 () Int) +(declare-fun x_284 () Int) +(declare-fun x_285 () Int) +(declare-fun x_286 () Int) +(declare-fun x_287 () Int) +(declare-fun x_288 () Bool) +(declare-fun x_289 () Bool) +(declare-fun x_290 () Bool) +(declare-fun x_291 () Bool) +(declare-fun x_292 () Bool) +(declare-fun x_293 () Bool) +(declare-fun x_294 () Bool) +(declare-fun x_295 () Bool) +(declare-fun x_296 () Int) +(declare-fun x_297 () Int) +(declare-fun x_298 () Int) +(declare-fun x_299 () Bool) +(declare-fun x_300 () Bool) +(declare-fun x_301 () Bool) +(declare-fun x_302 () Bool) +(declare-fun x_303 () Bool) +(declare-fun x_304 () Bool) +(declare-fun x_305 () Bool) +(declare-fun x_306 () Bool) +(declare-fun x_307 () Bool) +(declare-fun x_308 () Bool) +(declare-fun x_309 () Bool) +(declare-fun x_310 () Bool) +(declare-fun x_311 () Bool) +(declare-fun x_312 () Bool) +(declare-fun x_313 () Bool) +(declare-fun x_314 () Bool) +(declare-fun x_315 () Int) +(declare-fun x_316 () Int) +(declare-fun x_317 () Int) +(declare-fun x_318 () Int) +(declare-fun x_319 () Int) +(declare-fun x_320 () Int) +(declare-fun x_321 () Int) +(declare-fun x_322 () Int) +(declare-fun x_323 () Bool) +(declare-fun x_324 () Bool) +(declare-fun x_325 () Bool) +(declare-fun x_326 () Bool) +(declare-fun x_327 () Bool) +(declare-fun x_328 () Bool) +(declare-fun x_329 () Bool) +(declare-fun x_330 () Bool) +(declare-fun x_331 () Int) +(declare-fun x_332 () Int) +(declare-fun x_333 () Int) +(declare-fun x_334 () Int) +(declare-fun x_335 () Int) +(declare-fun x_336 () Int) +(declare-fun x_337 () Int) +(declare-fun x_338 () Int) +(declare-fun x_339 () Int) +(declare-fun x_340 () Int) +(declare-fun x_341 () Int) +(declare-fun x_342 () Int) +(declare-fun x_343 () Bool) +(declare-fun x_344 () Bool) +(declare-fun x_345 () Bool) +(declare-fun x_346 () Bool) +(declare-fun x_347 () Bool) +(declare-fun x_348 () Bool) +(declare-fun x_349 () Bool) +(declare-fun x_350 () Bool) +(declare-fun x_351 () Int) +(declare-fun x_352 () Int) +(declare-fun x_353 () Int) +(declare-fun x_354 () Bool) +(declare-fun x_355 () Bool) +(declare-fun x_356 () Bool) +(declare-fun x_357 () Bool) +(declare-fun x_358 () Bool) +(declare-fun x_359 () Bool) +(declare-fun x_360 () Bool) +(declare-fun x_361 () Bool) +(declare-fun x_362 () Bool) +(declare-fun x_363 () Bool) +(declare-fun x_364 () Bool) +(declare-fun x_365 () Bool) +(declare-fun x_366 () Bool) +(declare-fun x_367 () Bool) +(declare-fun x_368 () Bool) +(declare-fun x_369 () Bool) +(declare-fun x_370 () Int) +(declare-fun x_371 () Int) +(declare-fun x_372 () Int) +(declare-fun x_373 () Int) +(declare-fun x_374 () Int) +(declare-fun x_375 () Int) +(declare-fun x_376 () Int) +(declare-fun x_377 () Int) +(declare-fun x_378 () Bool) +(declare-fun x_379 () Bool) +(declare-fun x_380 () Bool) +(declare-fun x_381 () Bool) +(declare-fun x_382 () Bool) +(declare-fun x_383 () Bool) +(declare-fun x_384 () Bool) +(declare-fun x_385 () Bool) +(declare-fun x_386 () Int) +(declare-fun x_387 () Int) +(declare-fun x_388 () Int) +(declare-fun x_389 () Int) +(declare-fun x_390 () Int) +(declare-fun x_391 () Int) +(declare-fun x_392 () Int) +(declare-fun x_393 () Int) +(declare-fun x_394 () Int) +(declare-fun x_395 () Int) +(declare-fun x_396 () Int) +(declare-fun x_397 () Int) +(declare-fun x_398 () Bool) +(declare-fun x_399 () Bool) +(declare-fun x_400 () Bool) +(declare-fun x_401 () Bool) +(declare-fun x_402 () Bool) +(declare-fun x_403 () Bool) +(declare-fun x_404 () Bool) +(declare-fun x_405 () Bool) +(declare-fun x_406 () Int) +(declare-fun x_407 () Int) +(declare-fun x_408 () Int) +(declare-fun x_409 () Bool) +(declare-fun x_410 () Bool) +(declare-fun x_411 () Bool) +(declare-fun x_412 () Bool) +(declare-fun x_413 () Bool) +(declare-fun x_414 () Bool) +(declare-fun x_415 () Bool) +(declare-fun x_416 () Bool) +(declare-fun x_417 () Bool) +(declare-fun x_418 () Bool) +(declare-fun x_419 () Bool) +(declare-fun x_420 () Bool) +(declare-fun x_421 () Bool) +(declare-fun x_422 () Bool) +(declare-fun x_423 () Bool) +(declare-fun x_424 () Bool) +(declare-fun x_425 () Int) +(declare-fun x_426 () Int) +(declare-fun x_427 () Int) +(declare-fun x_428 () Int) +(declare-fun x_429 () Int) +(declare-fun x_430 () Int) +(declare-fun x_431 () Int) +(declare-fun x_432 () Int) +(declare-fun x_433 () Bool) +(declare-fun x_434 () Bool) +(declare-fun x_435 () Bool) +(declare-fun x_436 () Bool) +(declare-fun x_437 () Bool) +(declare-fun x_438 () Bool) +(declare-fun x_439 () Bool) +(declare-fun x_440 () Bool) +(declare-fun x_441 () Int) +(declare-fun x_442 () Int) +(declare-fun x_443 () Int) +(declare-fun x_444 () Int) +(declare-fun x_445 () Int) +(declare-fun x_446 () Int) +(declare-fun x_447 () Int) +(declare-fun x_448 () Int) +(declare-fun x_449 () Int) +(declare-fun x_450 () Int) +(declare-fun x_451 () Int) +(declare-fun x_452 () Int) +(declare-fun x_453 () Bool) +(declare-fun x_454 () Bool) +(declare-fun x_455 () Bool) +(declare-fun x_456 () Bool) +(declare-fun x_457 () Bool) +(declare-fun x_458 () Bool) +(declare-fun x_459 () Bool) +(declare-fun x_460 () Bool) +(declare-fun x_461 () Int) +(declare-fun x_462 () Int) +(declare-fun x_463 () Int) +(declare-fun x_464 () Bool) +(declare-fun x_465 () Bool) +(declare-fun x_466 () Bool) +(declare-fun x_467 () Bool) +(declare-fun x_468 () Bool) +(declare-fun x_469 () Bool) +(declare-fun x_470 () Bool) +(declare-fun x_471 () Bool) +(declare-fun x_472 () Bool) +(declare-fun x_473 () Bool) +(declare-fun x_474 () Bool) +(declare-fun x_475 () Bool) +(declare-fun x_476 () Bool) +(declare-fun x_477 () Bool) +(declare-fun x_478 () Bool) +(declare-fun x_479 () Bool) +(declare-fun x_480 () Int) +(declare-fun x_481 () Int) +(declare-fun x_482 () Int) +(declare-fun x_483 () Int) +(declare-fun x_484 () Int) +(declare-fun x_485 () Int) +(declare-fun x_486 () Int) +(declare-fun x_487 () Int) +(declare-fun x_488 () Bool) +(declare-fun x_489 () Bool) +(declare-fun x_490 () Bool) +(declare-fun x_491 () Bool) +(declare-fun x_492 () Bool) +(declare-fun x_493 () Bool) +(declare-fun x_494 () Bool) +(declare-fun x_495 () Bool) +(declare-fun x_496 () Int) +(declare-fun x_497 () Int) +(declare-fun x_498 () Int) +(declare-fun x_499 () Int) +(declare-fun x_500 () Int) +(declare-fun x_501 () Int) +(declare-fun x_502 () Int) +(declare-fun x_503 () Int) +(declare-fun x_504 () Int) +(declare-fun x_505 () Int) +(declare-fun x_506 () Int) +(declare-fun x_507 () Int) +(declare-fun x_508 () Bool) +(declare-fun x_509 () Bool) +(declare-fun x_510 () Bool) +(declare-fun x_511 () Bool) +(declare-fun x_512 () Bool) +(declare-fun x_513 () Bool) +(declare-fun x_514 () Bool) +(declare-fun x_515 () Bool) +(declare-fun x_516 () Int) +(declare-fun x_517 () Int) +(declare-fun x_518 () Int) +(declare-fun x_519 () Bool) +(declare-fun x_520 () Bool) +(declare-fun x_521 () Bool) +(declare-fun x_522 () Bool) +(declare-fun x_523 () Bool) +(declare-fun x_524 () Bool) +(declare-fun x_525 () Bool) +(declare-fun x_526 () Bool) +(declare-fun x_527 () Bool) +(declare-fun x_528 () Bool) +(declare-fun x_529 () Bool) +(declare-fun x_530 () Bool) +(declare-fun x_531 () Bool) +(declare-fun x_532 () Bool) +(declare-fun x_533 () Bool) +(declare-fun x_534 () Bool) +(declare-fun x_535 () Int) +(declare-fun x_536 () Int) +(declare-fun x_537 () Int) +(declare-fun x_538 () Int) +(declare-fun x_539 () Int) +(declare-fun x_540 () Int) +(assert (let ((?v_1060 (= x_48 x_16)) (?v_1061 (= x_49 x_17)) (?v_1035 (= x_50 x_18)) (?v_1036 (= x_51 x_19)) (?v_1037 (= x_52 x_20)) (?v_1038 (= x_53 x_21)) (?v_1039 (= x_54 x_22)) (?v_1040 (= x_55 x_23))) (let ((?v_1079 (and (and (and (and (and (and (and ?v_1060 ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (?v_1058 (= x_68 x_24)) (?v_1059 (= x_69 x_25)) (?v_1029 (= x_70 x_26)) (?v_1030 (= x_71 x_27)) (?v_1031 (= x_72 x_28)) (?v_1032 (= x_73 x_29)) (?v_1033 (= x_74 x_30)) (?v_1034 (= x_75 x_31))) (let ((?v_1080 (and (and (and (and (and (and (and ?v_1058 ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034)) (?v_1004 (and (= x_79 x_0) (= x_80 x_1))) (?v_1005 (and (= x_81 x_2) (= x_82 x_3))) (?v_996 (and (= x_83 x_4) (= x_84 x_5))) (?v_998 (and (= x_85 x_6) (= x_86 x_7))) (?v_995 (and (= x_87 x_8) (= x_88 x_9))) (?v_991 (and (= x_89 x_10) (= x_90 x_11))) (?v_997 (and (= x_91 x_12) (= x_92 x_13))) (?v_999 (and (= x_93 x_14) (= x_94 x_15))) (?v_951 (= x_103 x_48)) (?v_952 (= x_104 x_49)) (?v_930 (= x_105 x_50)) (?v_931 (= x_106 x_51)) (?v_932 (= x_107 x_52)) (?v_933 (= x_108 x_53)) (?v_934 (= x_109 x_54)) (?v_935 (= x_110 x_55))) (let ((?v_978 (and (and (and (and (and (and (and ?v_951 ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935)) (?v_949 (= x_123 x_68)) (?v_950 (= x_124 x_69)) (?v_924 (= x_125 x_70)) (?v_925 (= x_126 x_71)) (?v_926 (= x_127 x_72)) (?v_927 (= x_128 x_73)) (?v_928 (= x_129 x_74)) (?v_929 (= x_130 x_75))) (let ((?v_979 (and (and (and (and (and (and (and ?v_949 ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929)) (?v_903 (and (= x_134 x_79) (= x_135 x_80))) (?v_904 (and (= x_136 x_81) (= x_137 x_82))) (?v_895 (and (= x_138 x_83) (= x_139 x_84))) (?v_897 (and (= x_140 x_85) (= x_141 x_86))) (?v_894 (and (= x_142 x_87) (= x_143 x_88))) (?v_889 (and (= x_144 x_89) (= x_145 x_90))) (?v_896 (and (= x_146 x_91) (= x_147 x_92))) (?v_898 (and (= x_148 x_93) (= x_149 x_94))) (?v_850 (= x_158 x_103)) (?v_851 (= x_159 x_104)) (?v_829 (= x_160 x_105)) (?v_830 (= x_161 x_106)) (?v_831 (= x_162 x_107)) (?v_832 (= x_163 x_108)) (?v_833 (= x_164 x_109)) (?v_834 (= x_165 x_110))) (let ((?v_877 (and (and (and (and (and (and (and ?v_850 ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834)) (?v_848 (= x_178 x_123)) (?v_849 (= x_179 x_124)) (?v_823 (= x_180 x_125)) (?v_824 (= x_181 x_126)) (?v_825 (= x_182 x_127)) (?v_826 (= x_183 x_128)) (?v_827 (= x_184 x_129)) (?v_828 (= x_185 x_130))) (let ((?v_878 (and (and (and (and (and (and (and ?v_848 ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828)) (?v_802 (and (= x_189 x_134) (= x_190 x_135))) (?v_803 (and (= x_191 x_136) (= x_192 x_137))) (?v_794 (and (= x_193 x_138) (= x_194 x_139))) (?v_796 (and (= x_195 x_140) (= x_196 x_141))) (?v_793 (and (= x_197 x_142) (= x_198 x_143))) (?v_788 (and (= x_199 x_144) (= x_200 x_145))) (?v_795 (and (= x_201 x_146) (= x_202 x_147))) (?v_797 (and (= x_203 x_148) (= x_204 x_149))) (?v_749 (= x_213 x_158)) (?v_750 (= x_214 x_159)) (?v_728 (= x_215 x_160)) (?v_729 (= x_216 x_161)) (?v_730 (= x_217 x_162)) (?v_731 (= x_218 x_163)) (?v_732 (= x_219 x_164)) (?v_733 (= x_220 x_165))) (let ((?v_776 (and (and (and (and (and (and (and ?v_749 ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733)) (?v_747 (= x_233 x_178)) (?v_748 (= x_234 x_179)) (?v_722 (= x_235 x_180)) (?v_723 (= x_236 x_181)) (?v_724 (= x_237 x_182)) (?v_725 (= x_238 x_183)) (?v_726 (= x_239 x_184)) (?v_727 (= x_240 x_185))) (let ((?v_777 (and (and (and (and (and (and (and ?v_747 ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727)) (?v_701 (and (= x_244 x_189) (= x_245 x_190))) (?v_702 (and (= x_246 x_191) (= x_247 x_192))) (?v_693 (and (= x_248 x_193) (= x_249 x_194))) (?v_695 (and (= x_250 x_195) (= x_251 x_196))) (?v_692 (and (= x_252 x_197) (= x_253 x_198))) (?v_687 (and (= x_254 x_199) (= x_255 x_200))) (?v_694 (and (= x_256 x_201) (= x_257 x_202))) (?v_696 (and (= x_258 x_203) (= x_259 x_204))) (?v_648 (= x_268 x_213)) (?v_649 (= x_269 x_214)) (?v_627 (= x_270 x_215)) (?v_628 (= x_271 x_216)) (?v_629 (= x_272 x_217)) (?v_630 (= x_273 x_218)) (?v_631 (= x_274 x_219)) (?v_632 (= x_275 x_220))) (let ((?v_675 (and (and (and (and (and (and (and ?v_648 ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632)) (?v_646 (= x_288 x_233)) (?v_647 (= x_289 x_234)) (?v_621 (= x_290 x_235)) (?v_622 (= x_291 x_236)) (?v_623 (= x_292 x_237)) (?v_624 (= x_293 x_238)) (?v_625 (= x_294 x_239)) (?v_626 (= x_295 x_240))) (let ((?v_676 (and (and (and (and (and (and (and ?v_646 ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626)) (?v_600 (and (= x_299 x_244) (= x_300 x_245))) (?v_601 (and (= x_301 x_246) (= x_302 x_247))) (?v_592 (and (= x_303 x_248) (= x_304 x_249))) (?v_594 (and (= x_305 x_250) (= x_306 x_251))) (?v_591 (and (= x_307 x_252) (= x_308 x_253))) (?v_586 (and (= x_309 x_254) (= x_310 x_255))) (?v_593 (and (= x_311 x_256) (= x_312 x_257))) (?v_595 (and (= x_313 x_258) (= x_314 x_259))) (?v_547 (= x_323 x_268)) (?v_548 (= x_324 x_269)) (?v_526 (= x_325 x_270)) (?v_527 (= x_326 x_271)) (?v_528 (= x_327 x_272)) (?v_529 (= x_328 x_273)) (?v_530 (= x_329 x_274)) (?v_531 (= x_330 x_275))) (let ((?v_574 (and (and (and (and (and (and (and ?v_547 ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531)) (?v_545 (= x_343 x_288)) (?v_546 (= x_344 x_289)) (?v_520 (= x_345 x_290)) (?v_521 (= x_346 x_291)) (?v_522 (= x_347 x_292)) (?v_523 (= x_348 x_293)) (?v_524 (= x_349 x_294)) (?v_525 (= x_350 x_295))) (let ((?v_575 (and (and (and (and (and (and (and ?v_545 ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525)) (?v_499 (and (= x_354 x_299) (= x_355 x_300))) (?v_500 (and (= x_356 x_301) (= x_357 x_302))) (?v_491 (and (= x_358 x_303) (= x_359 x_304))) (?v_493 (and (= x_360 x_305) (= x_361 x_306))) (?v_490 (and (= x_362 x_307) (= x_363 x_308))) (?v_485 (and (= x_364 x_309) (= x_365 x_310))) (?v_492 (and (= x_366 x_311) (= x_367 x_312))) (?v_494 (and (= x_368 x_313) (= x_369 x_314))) (?v_446 (= x_378 x_323)) (?v_447 (= x_379 x_324)) (?v_425 (= x_380 x_325)) (?v_426 (= x_381 x_326)) (?v_427 (= x_382 x_327)) (?v_428 (= x_383 x_328)) (?v_429 (= x_384 x_329)) (?v_430 (= x_385 x_330))) (let ((?v_473 (and (and (and (and (and (and (and ?v_446 ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430)) (?v_444 (= x_398 x_343)) (?v_445 (= x_399 x_344)) (?v_419 (= x_400 x_345)) (?v_420 (= x_401 x_346)) (?v_421 (= x_402 x_347)) (?v_422 (= x_403 x_348)) (?v_423 (= x_404 x_349)) (?v_424 (= x_405 x_350))) (let ((?v_474 (and (and (and (and (and (and (and ?v_444 ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424)) (?v_398 (and (= x_409 x_354) (= x_410 x_355))) (?v_399 (and (= x_411 x_356) (= x_412 x_357))) (?v_390 (and (= x_413 x_358) (= x_414 x_359))) (?v_392 (and (= x_415 x_360) (= x_416 x_361))) (?v_389 (and (= x_417 x_362) (= x_418 x_363))) (?v_384 (and (= x_419 x_364) (= x_420 x_365))) (?v_391 (and (= x_421 x_366) (= x_422 x_367))) (?v_393 (and (= x_423 x_368) (= x_424 x_369))) (?v_345 (= x_433 x_378)) (?v_346 (= x_434 x_379)) (?v_324 (= x_435 x_380)) (?v_325 (= x_436 x_381)) (?v_326 (= x_437 x_382)) (?v_327 (= x_438 x_383)) (?v_328 (= x_439 x_384)) (?v_329 (= x_440 x_385))) (let ((?v_372 (and (and (and (and (and (and (and ?v_345 ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329)) (?v_343 (= x_453 x_398)) (?v_344 (= x_454 x_399)) (?v_318 (= x_455 x_400)) (?v_319 (= x_456 x_401)) (?v_320 (= x_457 x_402)) (?v_321 (= x_458 x_403)) (?v_322 (= x_459 x_404)) (?v_323 (= x_460 x_405))) (let ((?v_373 (and (and (and (and (and (and (and ?v_343 ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323)) (?v_297 (and (= x_464 x_409) (= x_465 x_410))) (?v_298 (and (= x_466 x_411) (= x_467 x_412))) (?v_289 (and (= x_468 x_413) (= x_469 x_414))) (?v_291 (and (= x_470 x_415) (= x_471 x_416))) (?v_288 (and (= x_472 x_417) (= x_473 x_418))) (?v_283 (and (= x_474 x_419) (= x_475 x_420))) (?v_290 (and (= x_476 x_421) (= x_477 x_422))) (?v_292 (and (= x_478 x_423) (= x_479 x_424))) (?v_229 (= x_488 x_433)) (?v_230 (= x_489 x_434)) (?v_208 (= x_490 x_435)) (?v_209 (= x_491 x_436)) (?v_210 (= x_492 x_437)) (?v_211 (= x_493 x_438)) (?v_212 (= x_494 x_439)) (?v_213 (= x_495 x_440))) (let ((?v_271 (and (and (and (and (and (and (and ?v_229 ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213)) (?v_227 (= x_508 x_453)) (?v_228 (= x_509 x_454)) (?v_202 (= x_510 x_455)) (?v_203 (= x_511 x_456)) (?v_204 (= x_512 x_457)) (?v_205 (= x_513 x_458)) (?v_206 (= x_514 x_459)) (?v_207 (= x_515 x_460))) (let ((?v_272 (and (and (and (and (and (and (and ?v_227 ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207)) (?v_177 (and (= x_519 x_464) (= x_520 x_465))) (?v_178 (and (= x_521 x_466) (= x_522 x_467))) (?v_165 (and (= x_523 x_468) (= x_524 x_469))) (?v_167 (and (= x_525 x_470) (= x_526 x_471))) (?v_164 (and (= x_527 x_472) (= x_528 x_473))) (?v_155 (and (= x_529 x_474) (= x_530 x_475))) (?v_166 (and (= x_531 x_476) (= x_532 x_477))) (?v_168 (and (= x_533 x_478) (= x_534 x_479))) (?v_980 (not x_0)) (?v_981 (not x_1)) (?v_987 (not x_2)) (?v_988 (not x_3)) (?v_1000 (not x_4)) (?v_1001 (not x_5)) (?v_1006 (not x_6)) (?v_1007 (not x_7)) (?v_1012 (not x_8)) (?v_1013 (not x_9)) (?v_1042 (not x_10)) (?v_1043 (not x_11)) (?v_1062 (not x_12)) (?v_1063 (not x_13)) (?v_1066 (not x_14)) (?v_1067 (not x_15)) (?v_1014 (not x_24)) (?v_1015 (not x_25)) (?v_1044 (not x_26)) (?v_1045 (not x_27)) (?v_1064 (not x_28)) (?v_1065 (not x_29)) (?v_1068 (not x_30)) (?v_1069 (not x_31)) (?v_144 (not x_464)) (?v_142 (not x_465)) (?v_145 (not x_433)) (?v_143 (not x_434)) (?v_147 (not x_520)) (?v_149 (not x_528)) (?v_146 (not x_519)) (?v_148 (not x_527)) (?v_157 (not x_466)) (?v_153 (not x_467)) (?v_159 (not x_435)) (?v_154 (not x_436)) (?v_161 (not x_522)) (?v_163 (not x_530)) (?v_160 (not x_521)) (?v_162 (not x_529)) (?v_171 (not x_468)) (?v_169 (not x_469)) (?v_172 (not x_437)) (?v_170 (not x_438)) (?v_174 (not x_524)) (?v_176 (not x_532)) (?v_173 (not x_523)) (?v_175 (not x_531)) (?v_181 (not x_470)) (?v_179 (not x_471)) (?v_182 (not x_439)) (?v_180 (not x_440)) (?v_184 (not x_526)) (?v_186 (not x_534)) (?v_183 (not x_525)) (?v_185 (not x_533)) (?v_249 (not x_472)) (?v_234 (not x_473)) (?v_250 (not x_453)) (?v_235 (not x_454)) (?v_252 (not x_509)) (?v_253 (not x_488)) (?v_236 (not x_489)) (?v_255 (not x_474)) (?v_238 (not x_475)) (?v_256 (not x_455)) (?v_239 (not x_456)) (?v_258 (not x_511)) (?v_259 (not x_490)) (?v_241 (not x_491)) (?v_260 (not x_476)) (?v_242 (not x_477)) (?v_261 (not x_457)) (?v_243 (not x_458)) (?v_263 (not x_513)) (?v_264 (not x_492)) (?v_244 (not x_493)) (?v_265 (not x_478)) (?v_245 (not x_479)) (?v_266 (not x_459)) (?v_246 (not x_460)) (?v_268 (not x_515)) (?v_269 (not x_494)) (?v_247 (not x_495)) (?v_251 (not x_508)) (?v_257 (not x_510)) (?v_262 (not x_512)) (?v_267 (not x_514)) (?v_276 (not x_409)) (?v_274 (not x_410)) (?v_277 (not x_378)) (?v_275 (not x_379)) (?v_285 (not x_411)) (?v_281 (not x_412)) (?v_287 (not x_380)) (?v_282 (not x_381)) (?v_295 (not x_413)) (?v_293 (not x_414)) (?v_296 (not x_382)) (?v_294 (not x_383)) (?v_301 (not x_415)) (?v_299 (not x_416)) (?v_302 (not x_384)) (?v_300 (not x_385)) (?v_361 (not x_417)) (?v_350 (not x_418)) (?v_362 (not x_398)) (?v_351 (not x_399)) (?v_364 (not x_419)) (?v_353 (not x_420)) (?v_365 (not x_400)) (?v_354 (not x_401)) (?v_366 (not x_421)) (?v_356 (not x_422)) (?v_367 (not x_402)) (?v_357 (not x_403)) (?v_368 (not x_423)) (?v_358 (not x_424)) (?v_369 (not x_404)) (?v_359 (not x_405)) (?v_377 (not x_354)) (?v_375 (not x_355)) (?v_378 (not x_323)) (?v_376 (not x_324)) (?v_386 (not x_356)) (?v_382 (not x_357)) (?v_388 (not x_325)) (?v_383 (not x_326)) (?v_396 (not x_358)) (?v_394 (not x_359)) (?v_397 (not x_327)) (?v_395 (not x_328)) (?v_402 (not x_360)) (?v_400 (not x_361)) (?v_403 (not x_329)) (?v_401 (not x_330)) (?v_462 (not x_362)) (?v_451 (not x_363)) (?v_463 (not x_343)) (?v_452 (not x_344)) (?v_465 (not x_364)) (?v_454 (not x_365)) (?v_466 (not x_345)) (?v_455 (not x_346)) (?v_467 (not x_366)) (?v_457 (not x_367)) (?v_468 (not x_347)) (?v_458 (not x_348)) (?v_469 (not x_368)) (?v_459 (not x_369)) (?v_470 (not x_349)) (?v_460 (not x_350)) (?v_478 (not x_299)) (?v_476 (not x_300)) (?v_479 (not x_268)) (?v_477 (not x_269)) (?v_487 (not x_301)) (?v_483 (not x_302)) (?v_489 (not x_270)) (?v_484 (not x_271)) (?v_497 (not x_303)) (?v_495 (not x_304)) (?v_498 (not x_272)) (?v_496 (not x_273)) (?v_503 (not x_305)) (?v_501 (not x_306)) (?v_504 (not x_274)) (?v_502 (not x_275)) (?v_563 (not x_307)) (?v_552 (not x_308)) (?v_564 (not x_288)) (?v_553 (not x_289)) (?v_566 (not x_309)) (?v_555 (not x_310)) (?v_567 (not x_290)) (?v_556 (not x_291)) (?v_568 (not x_311)) (?v_558 (not x_312)) (?v_569 (not x_292)) (?v_559 (not x_293)) (?v_570 (not x_313)) (?v_560 (not x_314)) (?v_571 (not x_294)) (?v_561 (not x_295)) (?v_579 (not x_244)) (?v_577 (not x_245)) (?v_580 (not x_213)) (?v_578 (not x_214)) (?v_588 (not x_246)) (?v_584 (not x_247)) (?v_590 (not x_215)) (?v_585 (not x_216)) (?v_598 (not x_248)) (?v_596 (not x_249)) (?v_599 (not x_217)) (?v_597 (not x_218)) (?v_604 (not x_250)) (?v_602 (not x_251)) (?v_605 (not x_219)) (?v_603 (not x_220)) (?v_664 (not x_252)) (?v_653 (not x_253)) (?v_665 (not x_233)) (?v_654 (not x_234)) (?v_667 (not x_254)) (?v_656 (not x_255)) (?v_668 (not x_235)) (?v_657 (not x_236)) (?v_669 (not x_256)) (?v_659 (not x_257)) (?v_670 (not x_237)) (?v_660 (not x_238)) (?v_671 (not x_258)) (?v_661 (not x_259)) (?v_672 (not x_239)) (?v_662 (not x_240)) (?v_680 (not x_189)) (?v_678 (not x_190)) (?v_681 (not x_158)) (?v_679 (not x_159)) (?v_689 (not x_191)) (?v_685 (not x_192)) (?v_691 (not x_160)) (?v_686 (not x_161)) (?v_699 (not x_193)) (?v_697 (not x_194)) (?v_700 (not x_162)) (?v_698 (not x_163)) (?v_705 (not x_195)) (?v_703 (not x_196)) (?v_706 (not x_164)) (?v_704 (not x_165)) (?v_765 (not x_197)) (?v_754 (not x_198)) (?v_766 (not x_178)) (?v_755 (not x_179)) (?v_768 (not x_199)) (?v_757 (not x_200)) (?v_769 (not x_180)) (?v_758 (not x_181)) (?v_770 (not x_201)) (?v_760 (not x_202)) (?v_771 (not x_182)) (?v_761 (not x_183)) (?v_772 (not x_203)) (?v_762 (not x_204)) (?v_773 (not x_184)) (?v_763 (not x_185)) (?v_781 (not x_134)) (?v_779 (not x_135)) (?v_782 (not x_103)) (?v_780 (not x_104)) (?v_790 (not x_136)) (?v_786 (not x_137)) (?v_792 (not x_105)) (?v_787 (not x_106)) (?v_800 (not x_138)) (?v_798 (not x_139)) (?v_801 (not x_107)) (?v_799 (not x_108)) (?v_806 (not x_140)) (?v_804 (not x_141)) (?v_807 (not x_109)) (?v_805 (not x_110)) (?v_866 (not x_142)) (?v_855 (not x_143)) (?v_867 (not x_123)) (?v_856 (not x_124)) (?v_869 (not x_144)) (?v_858 (not x_145)) (?v_870 (not x_125)) (?v_859 (not x_126)) (?v_871 (not x_146)) (?v_861 (not x_147)) (?v_872 (not x_127)) (?v_862 (not x_128)) (?v_873 (not x_148)) (?v_863 (not x_149)) (?v_874 (not x_129)) (?v_864 (not x_130)) (?v_882 (not x_79)) (?v_880 (not x_80)) (?v_883 (not x_48)) (?v_881 (not x_49)) (?v_891 (not x_81)) (?v_887 (not x_82)) (?v_893 (not x_50)) (?v_888 (not x_51)) (?v_901 (not x_83)) (?v_899 (not x_84)) (?v_902 (not x_52)) (?v_900 (not x_53)) (?v_907 (not x_85)) (?v_905 (not x_86)) (?v_908 (not x_54)) (?v_906 (not x_55)) (?v_967 (not x_87)) (?v_956 (not x_88)) (?v_968 (not x_68)) (?v_957 (not x_69)) (?v_970 (not x_89)) (?v_959 (not x_90)) (?v_971 (not x_70)) (?v_960 (not x_71)) (?v_972 (not x_91)) (?v_962 (not x_92)) (?v_973 (not x_72)) (?v_963 (not x_73)) (?v_974 (not x_93)) (?v_964 (not x_94)) (?v_975 (not x_74)) (?v_965 (not x_75)) (?v_984 (not x_16)) (?v_983 (not x_17)) (?v_994 (not x_18)) (?v_990 (not x_19)) (?v_1003 (not x_20)) (?v_1002 (not x_21)) (?v_1009 (not x_22)) (?v_1008 (not x_23))) (let ((?v_1082 (and ?v_146 x_520)) (?v_1081 (and ?v_160 x_522)) (?v_1083 (and ?v_173 x_524)) (?v_1084 (and ?v_183 x_526))) (let ((?v_1085 (or ?v_1082 ?v_1081)) (?v_1087 (and ?v_144 x_465)) (?v_1086 (and ?v_157 x_467)) (?v_1088 (and ?v_171 x_469)) (?v_1089 (and ?v_181 x_471))) (let ((?v_1090 (or ?v_1087 ?v_1086)) (?v_1092 (and ?v_276 x_410)) (?v_1091 (and ?v_285 x_412)) (?v_1093 (and ?v_295 x_414)) (?v_1094 (and ?v_301 x_416))) (let ((?v_1095 (or ?v_1092 ?v_1091)) (?v_1097 (and ?v_377 x_355)) (?v_1096 (and ?v_386 x_357)) (?v_1098 (and ?v_396 x_359)) (?v_1099 (and ?v_402 x_361))) (let ((?v_1100 (or ?v_1097 ?v_1096)) (?v_1102 (and ?v_478 x_300)) (?v_1101 (and ?v_487 x_302)) (?v_1103 (and ?v_497 x_304)) (?v_1104 (and ?v_503 x_306))) (let ((?v_1105 (or ?v_1102 ?v_1101)) (?v_1107 (and ?v_579 x_245)) (?v_1106 (and ?v_588 x_247)) (?v_1108 (and ?v_598 x_249)) (?v_1109 (and ?v_604 x_251))) (let ((?v_1110 (or ?v_1107 ?v_1106)) (?v_1112 (and ?v_680 x_190)) (?v_1111 (and ?v_689 x_192)) (?v_1113 (and ?v_699 x_194)) (?v_1114 (and ?v_705 x_196))) (let ((?v_1115 (or ?v_1112 ?v_1111)) (?v_1117 (and ?v_781 x_135)) (?v_1116 (and ?v_790 x_137)) (?v_1118 (and ?v_800 x_139)) (?v_1119 (and ?v_806 x_141))) (let ((?v_1120 (or ?v_1117 ?v_1116)) (?v_1122 (and ?v_882 x_80)) (?v_1121 (and ?v_891 x_82)) (?v_1123 (and ?v_901 x_84)) (?v_1124 (and ?v_907 x_86))) (let ((?v_1125 (or ?v_1122 ?v_1121)) (?v_1127 (and ?v_980 x_1)) (?v_1126 (and ?v_987 x_3)) (?v_1128 (and ?v_1000 x_5)) (?v_1129 (and ?v_1006 x_7))) (let ((?v_1130 (or ?v_1127 ?v_1126)) (?v_12 (- x_44 cvclZero))) (let ((?v_140 (= ?v_12 1)) (?v_27 (- x_77 cvclZero))) (let ((?v_1078 (= ?v_27 1)) (?v_41 (- x_132 cvclZero))) (let ((?v_977 (= ?v_41 1)) (?v_55 (- x_187 cvclZero))) (let ((?v_876 (= ?v_55 1)) (?v_69 (- x_242 cvclZero))) (let ((?v_775 (= ?v_69 1)) (?v_83 (- x_297 cvclZero))) (let ((?v_674 (= ?v_83 1)) (?v_97 (- x_352 cvclZero))) (let ((?v_573 (= ?v_97 1)) (?v_111 (- x_407 cvclZero))) (let ((?v_472 (= ?v_111 1)) (?v_125 (- x_462 cvclZero))) (let ((?v_371 (= ?v_125 1)) (?v_141 (- x_516 cvclZero))) (let ((?v_151 (= ?v_141 0)) (?v_152 (= ?v_141 1)) (?v_156 (= ?v_141 2)) (?v_158 (= ?v_141 3)) (?v_233 (= (- x_486 x_431) 0)) (?v_248 (- x_517 x_462))) (let ((?v_188 (= ?v_248 0)) (?v_189 (= (- x_496 x_441) 0)) (?v_191 (= (- x_497 x_442) 0)) (?v_192 (= (- x_498 x_443) 0)) (?v_193 (= (- x_499 x_444) 0)) (?v_194 (= (- x_500 x_445) 0)) (?v_195 (= (- x_501 x_446) 0)) (?v_196 (= (- x_502 x_447) 0)) (?v_197 (= (- x_503 x_448) 0)) (?v_198 (= (- x_504 x_449) 0)) (?v_199 (= (- x_505 x_450) 0)) (?v_200 (= (- x_506 x_451) 0)) (?v_201 (= (- x_507 x_452) 0))) (let ((?v_232 (and (and (and (and (and (and (and (and (and (and (and ?v_189 ?v_191) ?v_192) ?v_193) ?v_194) ?v_195) ?v_196) ?v_197) ?v_198) ?v_199) ?v_200) ?v_201)) (?v_112 (- x_431 cvclZero))) (let ((?v_270 (= ?v_112 10)) (?v_190 (- x_487 cvclZero))) (let ((?v_215 (= ?v_190 0)) (?v_216 (= ?v_190 1)) (?v_217 (= ?v_190 2)) (?v_218 (= ?v_190 3)) (?v_219 (= ?v_190 4)) (?v_220 (= ?v_190 5)) (?v_221 (= ?v_190 6)) (?v_222 (= ?v_190 7)) (?v_223 (= ?v_190 8)) (?v_224 (= ?v_190 9)) (?v_225 (= ?v_190 10)) (?v_226 (= ?v_190 11)) (?v_273 (- x_461 cvclZero))) (let ((?v_279 (= ?v_273 0)) (?v_280 (= ?v_273 1)) (?v_284 (= ?v_273 2)) (?v_286 (= ?v_273 3)) (?v_349 (= (- x_431 x_376) 0)) (?v_360 (- x_462 x_407))) (let ((?v_304 (= ?v_360 0)) (?v_305 (= (- x_441 x_386) 0)) (?v_307 (= (- x_442 x_387) 0)) (?v_308 (= (- x_443 x_388) 0)) (?v_309 (= (- x_444 x_389) 0)) (?v_310 (= (- x_445 x_390) 0)) (?v_311 (= (- x_446 x_391) 0)) (?v_312 (= (- x_447 x_392) 0)) (?v_313 (= (- x_448 x_393) 0)) (?v_314 (= (- x_449 x_394) 0)) (?v_315 (= (- x_450 x_395) 0)) (?v_316 (= (- x_451 x_396) 0)) (?v_317 (= (- x_452 x_397) 0))) (let ((?v_348 (and (and (and (and (and (and (and (and (and (and (and ?v_305 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312) ?v_313) ?v_314) ?v_315) ?v_316) ?v_317)) (?v_98 (- x_376 cvclZero))) (let ((?v_370 (= ?v_98 10)) (?v_306 (- x_432 cvclZero))) (let ((?v_331 (= ?v_306 0)) (?v_332 (= ?v_306 1)) (?v_333 (= ?v_306 2)) (?v_334 (= ?v_306 3)) (?v_335 (= ?v_306 4)) (?v_336 (= ?v_306 5)) (?v_337 (= ?v_306 6)) (?v_338 (= ?v_306 7)) (?v_339 (= ?v_306 8)) (?v_340 (= ?v_306 9)) (?v_341 (= ?v_306 10)) (?v_342 (= ?v_306 11)) (?v_374 (- x_406 cvclZero))) (let ((?v_380 (= ?v_374 0)) (?v_381 (= ?v_374 1)) (?v_385 (= ?v_374 2)) (?v_387 (= ?v_374 3)) (?v_450 (= (- x_376 x_321) 0)) (?v_461 (- x_407 x_352))) (let ((?v_405 (= ?v_461 0)) (?v_406 (= (- x_386 x_331) 0)) (?v_408 (= (- x_387 x_332) 0)) (?v_409 (= (- x_388 x_333) 0)) (?v_410 (= (- x_389 x_334) 0)) (?v_411 (= (- x_390 x_335) 0)) (?v_412 (= (- x_391 x_336) 0)) (?v_413 (= (- x_392 x_337) 0)) (?v_414 (= (- x_393 x_338) 0)) (?v_415 (= (- x_394 x_339) 0)) (?v_416 (= (- x_395 x_340) 0)) (?v_417 (= (- x_396 x_341) 0)) (?v_418 (= (- x_397 x_342) 0))) (let ((?v_449 (and (and (and (and (and (and (and (and (and (and (and ?v_406 ?v_408) ?v_409) ?v_410) ?v_411) ?v_412) ?v_413) ?v_414) ?v_415) ?v_416) ?v_417) ?v_418)) (?v_84 (- x_321 cvclZero))) (let ((?v_471 (= ?v_84 10)) (?v_407 (- x_377 cvclZero))) (let ((?v_432 (= ?v_407 0)) (?v_433 (= ?v_407 1)) (?v_434 (= ?v_407 2)) (?v_435 (= ?v_407 3)) (?v_436 (= ?v_407 4)) (?v_437 (= ?v_407 5)) (?v_438 (= ?v_407 6)) (?v_439 (= ?v_407 7)) (?v_440 (= ?v_407 8)) (?v_441 (= ?v_407 9)) (?v_442 (= ?v_407 10)) (?v_443 (= ?v_407 11)) (?v_475 (- x_351 cvclZero))) (let ((?v_481 (= ?v_475 0)) (?v_482 (= ?v_475 1)) (?v_486 (= ?v_475 2)) (?v_488 (= ?v_475 3)) (?v_551 (= (- x_321 x_266) 0)) (?v_562 (- x_352 x_297))) (let ((?v_506 (= ?v_562 0)) (?v_507 (= (- x_331 x_276) 0)) (?v_509 (= (- x_332 x_277) 0)) (?v_510 (= (- x_333 x_278) 0)) (?v_511 (= (- x_334 x_279) 0)) (?v_512 (= (- x_335 x_280) 0)) (?v_513 (= (- x_336 x_281) 0)) (?v_514 (= (- x_337 x_282) 0)) (?v_515 (= (- x_338 x_283) 0)) (?v_516 (= (- x_339 x_284) 0)) (?v_517 (= (- x_340 x_285) 0)) (?v_518 (= (- x_341 x_286) 0)) (?v_519 (= (- x_342 x_287) 0))) (let ((?v_550 (and (and (and (and (and (and (and (and (and (and (and ?v_507 ?v_509) ?v_510) ?v_511) ?v_512) ?v_513) ?v_514) ?v_515) ?v_516) ?v_517) ?v_518) ?v_519)) (?v_70 (- x_266 cvclZero))) (let ((?v_572 (= ?v_70 10)) (?v_508 (- x_322 cvclZero))) (let ((?v_533 (= ?v_508 0)) (?v_534 (= ?v_508 1)) (?v_535 (= ?v_508 2)) (?v_536 (= ?v_508 3)) (?v_537 (= ?v_508 4)) (?v_538 (= ?v_508 5)) (?v_539 (= ?v_508 6)) (?v_540 (= ?v_508 7)) (?v_541 (= ?v_508 8)) (?v_542 (= ?v_508 9)) (?v_543 (= ?v_508 10)) (?v_544 (= ?v_508 11)) (?v_576 (- x_296 cvclZero))) (let ((?v_582 (= ?v_576 0)) (?v_583 (= ?v_576 1)) (?v_587 (= ?v_576 2)) (?v_589 (= ?v_576 3)) (?v_652 (= (- x_266 x_211) 0)) (?v_663 (- x_297 x_242))) (let ((?v_607 (= ?v_663 0)) (?v_608 (= (- x_276 x_221) 0)) (?v_610 (= (- x_277 x_222) 0)) (?v_611 (= (- x_278 x_223) 0)) (?v_612 (= (- x_279 x_224) 0)) (?v_613 (= (- x_280 x_225) 0)) (?v_614 (= (- x_281 x_226) 0)) (?v_615 (= (- x_282 x_227) 0)) (?v_616 (= (- x_283 x_228) 0)) (?v_617 (= (- x_284 x_229) 0)) (?v_618 (= (- x_285 x_230) 0)) (?v_619 (= (- x_286 x_231) 0)) (?v_620 (= (- x_287 x_232) 0))) (let ((?v_651 (and (and (and (and (and (and (and (and (and (and (and ?v_608 ?v_610) ?v_611) ?v_612) ?v_613) ?v_614) ?v_615) ?v_616) ?v_617) ?v_618) ?v_619) ?v_620)) (?v_56 (- x_211 cvclZero))) (let ((?v_673 (= ?v_56 10)) (?v_609 (- x_267 cvclZero))) (let ((?v_634 (= ?v_609 0)) (?v_635 (= ?v_609 1)) (?v_636 (= ?v_609 2)) (?v_637 (= ?v_609 3)) (?v_638 (= ?v_609 4)) (?v_639 (= ?v_609 5)) (?v_640 (= ?v_609 6)) (?v_641 (= ?v_609 7)) (?v_642 (= ?v_609 8)) (?v_643 (= ?v_609 9)) (?v_644 (= ?v_609 10)) (?v_645 (= ?v_609 11)) (?v_677 (- x_241 cvclZero))) (let ((?v_683 (= ?v_677 0)) (?v_684 (= ?v_677 1)) (?v_688 (= ?v_677 2)) (?v_690 (= ?v_677 3)) (?v_753 (= (- x_211 x_156) 0)) (?v_764 (- x_242 x_187))) (let ((?v_708 (= ?v_764 0)) (?v_709 (= (- x_221 x_166) 0)) (?v_711 (= (- x_222 x_167) 0)) (?v_712 (= (- x_223 x_168) 0)) (?v_713 (= (- x_224 x_169) 0)) (?v_714 (= (- x_225 x_170) 0)) (?v_715 (= (- x_226 x_171) 0)) (?v_716 (= (- x_227 x_172) 0)) (?v_717 (= (- x_228 x_173) 0)) (?v_718 (= (- x_229 x_174) 0)) (?v_719 (= (- x_230 x_175) 0)) (?v_720 (= (- x_231 x_176) 0)) (?v_721 (= (- x_232 x_177) 0))) (let ((?v_752 (and (and (and (and (and (and (and (and (and (and (and ?v_709 ?v_711) ?v_712) ?v_713) ?v_714) ?v_715) ?v_716) ?v_717) ?v_718) ?v_719) ?v_720) ?v_721)) (?v_42 (- x_156 cvclZero))) (let ((?v_774 (= ?v_42 10)) (?v_710 (- x_212 cvclZero))) (let ((?v_735 (= ?v_710 0)) (?v_736 (= ?v_710 1)) (?v_737 (= ?v_710 2)) (?v_738 (= ?v_710 3)) (?v_739 (= ?v_710 4)) (?v_740 (= ?v_710 5)) (?v_741 (= ?v_710 6)) (?v_742 (= ?v_710 7)) (?v_743 (= ?v_710 8)) (?v_744 (= ?v_710 9)) (?v_745 (= ?v_710 10)) (?v_746 (= ?v_710 11)) (?v_778 (- x_186 cvclZero))) (let ((?v_784 (= ?v_778 0)) (?v_785 (= ?v_778 1)) (?v_789 (= ?v_778 2)) (?v_791 (= ?v_778 3)) (?v_854 (= (- x_156 x_101) 0)) (?v_865 (- x_187 x_132))) (let ((?v_809 (= ?v_865 0)) (?v_810 (= (- x_166 x_111) 0)) (?v_812 (= (- x_167 x_112) 0)) (?v_813 (= (- x_168 x_113) 0)) (?v_814 (= (- x_169 x_114) 0)) (?v_815 (= (- x_170 x_115) 0)) (?v_816 (= (- x_171 x_116) 0)) (?v_817 (= (- x_172 x_117) 0)) (?v_818 (= (- x_173 x_118) 0)) (?v_819 (= (- x_174 x_119) 0)) (?v_820 (= (- x_175 x_120) 0)) (?v_821 (= (- x_176 x_121) 0)) (?v_822 (= (- x_177 x_122) 0))) (let ((?v_853 (and (and (and (and (and (and (and (and (and (and (and ?v_810 ?v_812) ?v_813) ?v_814) ?v_815) ?v_816) ?v_817) ?v_818) ?v_819) ?v_820) ?v_821) ?v_822)) (?v_28 (- x_101 cvclZero))) (let ((?v_875 (= ?v_28 10)) (?v_811 (- x_157 cvclZero))) (let ((?v_836 (= ?v_811 0)) (?v_837 (= ?v_811 1)) (?v_838 (= ?v_811 2)) (?v_839 (= ?v_811 3)) (?v_840 (= ?v_811 4)) (?v_841 (= ?v_811 5)) (?v_842 (= ?v_811 6)) (?v_843 (= ?v_811 7)) (?v_844 (= ?v_811 8)) (?v_845 (= ?v_811 9)) (?v_846 (= ?v_811 10)) (?v_847 (= ?v_811 11)) (?v_879 (- x_131 cvclZero))) (let ((?v_885 (= ?v_879 0)) (?v_886 (= ?v_879 1)) (?v_890 (= ?v_879 2)) (?v_892 (= ?v_879 3)) (?v_955 (= (- x_101 x_46) 0)) (?v_966 (- x_132 x_77))) (let ((?v_910 (= ?v_966 0)) (?v_911 (= (- x_111 x_56) 0)) (?v_913 (= (- x_112 x_57) 0)) (?v_914 (= (- x_113 x_58) 0)) (?v_915 (= (- x_114 x_59) 0)) (?v_916 (= (- x_115 x_60) 0)) (?v_917 (= (- x_116 x_61) 0)) (?v_918 (= (- x_117 x_62) 0)) (?v_919 (= (- x_118 x_63) 0)) (?v_920 (= (- x_119 x_64) 0)) (?v_921 (= (- x_120 x_65) 0)) (?v_922 (= (- x_121 x_66) 0)) (?v_923 (= (- x_122 x_67) 0))) (let ((?v_954 (and (and (and (and (and (and (and (and (and (and (and ?v_911 ?v_913) ?v_914) ?v_915) ?v_916) ?v_917) ?v_918) ?v_919) ?v_920) ?v_921) ?v_922) ?v_923)) (?v_14 (- x_46 cvclZero))) (let ((?v_976 (= ?v_14 10)) (?v_912 (- x_102 cvclZero))) (let ((?v_937 (= ?v_912 0)) (?v_938 (= ?v_912 1)) (?v_939 (= ?v_912 2)) (?v_940 (= ?v_912 3)) (?v_941 (= ?v_912 4)) (?v_942 (= ?v_912 5)) (?v_943 (= ?v_912 6)) (?v_944 (= ?v_912 7)) (?v_945 (= ?v_912 8)) (?v_946 (= ?v_912 9)) (?v_947 (= ?v_912 10)) (?v_948 (= ?v_912 11)) (?v_982 (- x_76 cvclZero))) (let ((?v_986 (= ?v_982 0)) (?v_989 (= ?v_982 1)) (?v_992 (= ?v_982 2)) (?v_993 (= ?v_982 3)) (?v_1072 (= (- x_46 x_45) 0)) (?v_1075 (- x_77 x_44))) (let ((?v_1011 (= ?v_1075 0)) (?v_1016 (= (- x_56 x_32) 0)) (?v_1018 (= (- x_57 x_33) 0)) (?v_1019 (= (- x_58 x_34) 0)) (?v_1020 (= (- x_59 x_35) 0)) (?v_1021 (= (- x_60 x_36) 0)) (?v_1022 (= (- x_61 x_37) 0)) (?v_1023 (= (- x_62 x_38) 0)) (?v_1024 (= (- x_63 x_39) 0)) (?v_1025 (= (- x_64 x_40) 0)) (?v_1026 (= (- x_65 x_41) 0)) (?v_1027 (= (- x_66 x_42) 0)) (?v_1028 (= (- x_67 x_43) 0))) (let ((?v_1071 (and (and (and (and (and (and (and (and (and (and (and ?v_1016 ?v_1018) ?v_1019) ?v_1020) ?v_1021) ?v_1022) ?v_1023) ?v_1024) ?v_1025) ?v_1026) ?v_1027) ?v_1028)) (?v_13 (- x_45 cvclZero))) (let ((?v_1077 (= ?v_13 10)) (?v_1017 (- x_47 cvclZero))) (let ((?v_1046 (= ?v_1017 0)) (?v_1047 (= ?v_1017 1)) (?v_1048 (= ?v_1017 2)) (?v_1049 (= ?v_1017 3)) (?v_1050 (= ?v_1017 4)) (?v_1051 (= ?v_1017 5)) (?v_1052 (= ?v_1017 6)) (?v_1053 (= ?v_1017 7)) (?v_1054 (= ?v_1017 8)) (?v_1055 (= ?v_1017 9)) (?v_1056 (= ?v_1017 10)) (?v_1057 (= ?v_1017 11)) (?v_0 (- x_32 cvclZero)) (?v_1 (- x_33 cvclZero)) (?v_2 (- x_34 cvclZero)) (?v_3 (- x_35 cvclZero)) (?v_4 (- x_36 cvclZero)) (?v_5 (- x_37 cvclZero)) (?v_6 (- x_38 cvclZero)) (?v_7 (- x_39 cvclZero)) (?v_8 (- x_40 cvclZero)) (?v_9 (- x_41 cvclZero)) (?v_10 (- x_42 cvclZero)) (?v_11 (- x_43 cvclZero)) (?v_15 (- x_56 cvclZero)) (?v_16 (- x_57 cvclZero)) (?v_17 (- x_58 cvclZero)) (?v_18 (- x_59 cvclZero)) (?v_19 (- x_60 cvclZero)) (?v_20 (- x_61 cvclZero)) (?v_21 (- x_62 cvclZero)) (?v_22 (- x_63 cvclZero)) (?v_23 (- x_64 cvclZero)) (?v_24 (- x_65 cvclZero)) (?v_25 (- x_66 cvclZero)) (?v_26 (- x_67 cvclZero)) (?v_29 (- x_111 cvclZero)) (?v_30 (- x_112 cvclZero)) (?v_31 (- x_113 cvclZero)) (?v_32 (- x_114 cvclZero)) (?v_33 (- x_115 cvclZero)) (?v_34 (- x_116 cvclZero)) (?v_35 (- x_117 cvclZero)) (?v_36 (- x_118 cvclZero)) (?v_37 (- x_119 cvclZero)) (?v_38 (- x_120 cvclZero)) (?v_39 (- x_121 cvclZero)) (?v_40 (- x_122 cvclZero)) (?v_43 (- x_166 cvclZero)) (?v_44 (- x_167 cvclZero)) (?v_45 (- x_168 cvclZero)) (?v_46 (- x_169 cvclZero)) (?v_47 (- x_170 cvclZero)) (?v_48 (- x_171 cvclZero)) (?v_49 (- x_172 cvclZero)) (?v_50 (- x_173 cvclZero)) (?v_51 (- x_174 cvclZero)) (?v_52 (- x_175 cvclZero)) (?v_53 (- x_176 cvclZero)) (?v_54 (- x_177 cvclZero)) (?v_57 (- x_221 cvclZero)) (?v_58 (- x_222 cvclZero)) (?v_59 (- x_223 cvclZero)) (?v_60 (- x_224 cvclZero)) (?v_61 (- x_225 cvclZero)) (?v_62 (- x_226 cvclZero)) (?v_63 (- x_227 cvclZero)) (?v_64 (- x_228 cvclZero)) (?v_65 (- x_229 cvclZero)) (?v_66 (- x_230 cvclZero)) (?v_67 (- x_231 cvclZero)) (?v_68 (- x_232 cvclZero)) (?v_71 (- x_276 cvclZero)) (?v_72 (- x_277 cvclZero)) (?v_73 (- x_278 cvclZero)) (?v_74 (- x_279 cvclZero)) (?v_75 (- x_280 cvclZero)) (?v_76 (- x_281 cvclZero)) (?v_77 (- x_282 cvclZero)) (?v_78 (- x_283 cvclZero)) (?v_79 (- x_284 cvclZero)) (?v_80 (- x_285 cvclZero)) (?v_81 (- x_286 cvclZero)) (?v_82 (- x_287 cvclZero)) (?v_85 (- x_331 cvclZero)) (?v_86 (- x_332 cvclZero)) (?v_87 (- x_333 cvclZero)) (?v_88 (- x_334 cvclZero)) (?v_89 (- x_335 cvclZero)) (?v_90 (- x_336 cvclZero)) (?v_91 (- x_337 cvclZero)) (?v_92 (- x_338 cvclZero)) (?v_93 (- x_339 cvclZero)) (?v_94 (- x_340 cvclZero)) (?v_95 (- x_341 cvclZero)) (?v_96 (- x_342 cvclZero)) (?v_99 (- x_386 cvclZero)) (?v_100 (- x_387 cvclZero)) (?v_101 (- x_388 cvclZero)) (?v_102 (- x_389 cvclZero)) (?v_103 (- x_390 cvclZero)) (?v_104 (- x_391 cvclZero)) (?v_105 (- x_392 cvclZero)) (?v_106 (- x_393 cvclZero)) (?v_107 (- x_394 cvclZero)) (?v_108 (- x_395 cvclZero)) (?v_109 (- x_396 cvclZero)) (?v_110 (- x_397 cvclZero)) (?v_113 (- x_441 cvclZero)) (?v_114 (- x_442 cvclZero)) (?v_115 (- x_443 cvclZero)) (?v_116 (- x_444 cvclZero)) (?v_117 (- x_445 cvclZero)) (?v_118 (- x_446 cvclZero)) (?v_119 (- x_447 cvclZero)) (?v_120 (- x_448 cvclZero)) (?v_121 (- x_449 cvclZero)) (?v_122 (- x_450 cvclZero)) (?v_123 (- x_451 cvclZero)) (?v_124 (- x_452 cvclZero)) (?v_126 (- x_486 cvclZero)) (?v_127 (- x_496 cvclZero)) (?v_128 (- x_497 cvclZero)) (?v_129 (- x_498 cvclZero)) (?v_130 (- x_499 cvclZero)) (?v_131 (- x_500 cvclZero)) (?v_132 (- x_501 cvclZero)) (?v_133 (- x_502 cvclZero)) (?v_134 (- x_503 cvclZero)) (?v_135 (- x_504 cvclZero)) (?v_136 (- x_505 cvclZero)) (?v_137 (- x_506 cvclZero)) (?v_138 (- x_507 cvclZero)) (?v_139 (- x_517 cvclZero)) (?v_187 (- x_535 cvclZero)) (?v_150 (- x_536 cvclZero)) (?v_231 (- x_537 cvclZero)) (?v_214 (- x_538 cvclZero)) (?v_237 (- x_539 cvclZero)) (?v_240 (- x_518 cvclZero)) (?v_254 (- x_540 cvclZero)) (?v_303 (- x_480 cvclZero)) (?v_278 (- x_481 cvclZero)) (?v_347 (- x_482 cvclZero)) (?v_330 (- x_483 cvclZero)) (?v_352 (- x_484 cvclZero)) (?v_355 (- x_463 cvclZero)) (?v_363 (- x_485 cvclZero)) (?v_404 (- x_425 cvclZero)) (?v_379 (- x_426 cvclZero)) (?v_448 (- x_427 cvclZero)) (?v_431 (- x_428 cvclZero)) (?v_453 (- x_429 cvclZero)) (?v_456 (- x_408 cvclZero)) (?v_464 (- x_430 cvclZero)) (?v_505 (- x_370 cvclZero)) (?v_480 (- x_371 cvclZero)) (?v_549 (- x_372 cvclZero)) (?v_532 (- x_373 cvclZero)) (?v_554 (- x_374 cvclZero)) (?v_557 (- x_353 cvclZero)) (?v_565 (- x_375 cvclZero)) (?v_606 (- x_315 cvclZero)) (?v_581 (- x_316 cvclZero)) (?v_650 (- x_317 cvclZero)) (?v_633 (- x_318 cvclZero)) (?v_655 (- x_319 cvclZero)) (?v_658 (- x_298 cvclZero)) (?v_666 (- x_320 cvclZero)) (?v_707 (- x_260 cvclZero)) (?v_682 (- x_261 cvclZero)) (?v_751 (- x_262 cvclZero)) (?v_734 (- x_263 cvclZero)) (?v_756 (- x_264 cvclZero)) (?v_759 (- x_243 cvclZero)) (?v_767 (- x_265 cvclZero)) (?v_808 (- x_205 cvclZero)) (?v_783 (- x_206 cvclZero)) (?v_852 (- x_207 cvclZero)) (?v_835 (- x_208 cvclZero)) (?v_857 (- x_209 cvclZero)) (?v_860 (- x_188 cvclZero)) (?v_868 (- x_210 cvclZero)) (?v_909 (- x_150 cvclZero)) (?v_884 (- x_151 cvclZero)) (?v_953 (- x_152 cvclZero)) (?v_936 (- x_153 cvclZero)) (?v_958 (- x_154 cvclZero)) (?v_961 (- x_133 cvclZero)) (?v_969 (- x_155 cvclZero)) (?v_1010 (- x_95 cvclZero)) (?v_985 (- x_96 cvclZero)) (?v_1070 (- x_97 cvclZero)) (?v_1041 (- x_98 cvclZero)) (?v_1073 (- x_99 cvclZero)) (?v_1074 (- x_78 cvclZero)) (?v_1076 (- x_100 cvclZero))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (< ?v_0 1)) (<= ?v_0 4)) (not (< ?v_1 1))) (<= ?v_1 4)) (not (< ?v_2 1))) (<= ?v_2 4)) (not (< ?v_3 1))) (<= ?v_3 4)) (not (< ?v_4 1))) (<= ?v_4 4)) (not (< ?v_5 1))) (<= ?v_5 4)) (not (< ?v_6 1))) (<= ?v_6 4)) (not (< ?v_7 1))) (<= ?v_7 4)) (not (< ?v_8 1))) (<= ?v_8 4)) (not (< ?v_9 1))) (<= ?v_9 4)) (not (< ?v_10 1))) (<= ?v_10 4)) (not (< ?v_11 1))) (<= ?v_11 4)) (not (< ?v_12 0))) (<= ?v_12 11)) (not (< ?v_13 0))) (<= ?v_13 11)) (not (< ?v_14 0))) (<= ?v_14 11)) (not (< ?v_15 1))) (<= ?v_15 4)) (not (< ?v_16 1))) (<= ?v_16 4)) (not (< ?v_17 1))) (<= ?v_17 4)) (not (< ?v_18 1))) (<= ?v_18 4)) (not (< ?v_19 1))) (<= ?v_19 4)) (not (< ?v_20 1))) (<= ?v_20 4)) (not (< ?v_21 1))) (<= ?v_21 4)) (not (< ?v_22 1))) (<= ?v_22 4)) (not (< ?v_23 1))) (<= ?v_23 4)) (not (< ?v_24 1))) (<= ?v_24 4)) (not (< ?v_25 1))) (<= ?v_25 4)) (not (< ?v_26 1))) (<= ?v_26 4)) (not (< ?v_27 0))) (<= ?v_27 11)) (not (< ?v_28 0))) (<= ?v_28 11)) (not (< ?v_29 1))) (<= ?v_29 4)) (not (< ?v_30 1))) (<= ?v_30 4)) (not (< ?v_31 1))) (<= ?v_31 4)) (not (< ?v_32 1))) (<= ?v_32 4)) (not (< ?v_33 1))) (<= ?v_33 4)) (not (< ?v_34 1))) (<= ?v_34 4)) (not (< ?v_35 1))) (<= ?v_35 4)) (not (< ?v_36 1))) (<= ?v_36 4)) (not (< ?v_37 1))) (<= ?v_37 4)) (not (< ?v_38 1))) (<= ?v_38 4)) (not (< ?v_39 1))) (<= ?v_39 4)) (not (< ?v_40 1))) (<= ?v_40 4)) (not (< ?v_41 0))) (<= ?v_41 11)) (not (< ?v_42 0))) (<= ?v_42 11)) (not (< ?v_43 1))) (<= ?v_43 4)) (not (< ?v_44 1))) (<= ?v_44 4)) (not (< ?v_45 1))) (<= ?v_45 4)) (not (< ?v_46 1))) (<= ?v_46 4)) (not (< ?v_47 1))) (<= ?v_47 4)) (not (< ?v_48 1))) (<= ?v_48 4)) (not (< ?v_49 1))) (<= ?v_49 4)) (not (< ?v_50 1))) (<= ?v_50 4)) (not (< ?v_51 1))) (<= ?v_51 4)) (not (< ?v_52 1))) (<= ?v_52 4)) (not (< ?v_53 1))) (<= ?v_53 4)) (not (< ?v_54 1))) (<= ?v_54 4)) (not (< ?v_55 0))) (<= ?v_55 11)) (not (< ?v_56 0))) (<= ?v_56 11)) (not (< ?v_57 1))) (<= ?v_57 4)) (not (< ?v_58 1))) (<= ?v_58 4)) (not (< ?v_59 1))) (<= ?v_59 4)) (not (< ?v_60 1))) (<= ?v_60 4)) (not (< ?v_61 1))) (<= ?v_61 4)) (not (< ?v_62 1))) (<= ?v_62 4)) (not (< ?v_63 1))) (<= ?v_63 4)) (not (< ?v_64 1))) (<= ?v_64 4)) (not (< ?v_65 1))) (<= ?v_65 4)) (not (< ?v_66 1))) (<= ?v_66 4)) (not (< ?v_67 1))) (<= ?v_67 4)) (not (< ?v_68 1))) (<= ?v_68 4)) (not (< ?v_69 0))) (<= ?v_69 11)) (not (< ?v_70 0))) (<= ?v_70 11)) (not (< ?v_71 1))) (<= ?v_71 4)) (not (< ?v_72 1))) (<= ?v_72 4)) (not (< ?v_73 1))) (<= ?v_73 4)) (not (< ?v_74 1))) (<= ?v_74 4)) (not (< ?v_75 1))) (<= ?v_75 4)) (not (< ?v_76 1))) (<= ?v_76 4)) (not (< ?v_77 1))) (<= ?v_77 4)) (not (< ?v_78 1))) (<= ?v_78 4)) (not (< ?v_79 1))) (<= ?v_79 4)) (not (< ?v_80 1))) (<= ?v_80 4)) (not (< ?v_81 1))) (<= ?v_81 4)) (not (< ?v_82 1))) (<= ?v_82 4)) (not (< ?v_83 0))) (<= ?v_83 11)) (not (< ?v_84 0))) (<= ?v_84 11)) (not (< ?v_85 1))) (<= ?v_85 4)) (not (< ?v_86 1))) (<= ?v_86 4)) (not (< ?v_87 1))) (<= ?v_87 4)) (not (< ?v_88 1))) (<= ?v_88 4)) (not (< ?v_89 1))) (<= ?v_89 4)) (not (< ?v_90 1))) (<= ?v_90 4)) (not (< ?v_91 1))) (<= ?v_91 4)) (not (< ?v_92 1))) (<= ?v_92 4)) (not (< ?v_93 1))) (<= ?v_93 4)) (not (< ?v_94 1))) (<= ?v_94 4)) (not (< ?v_95 1))) (<= ?v_95 4)) (not (< ?v_96 1))) (<= ?v_96 4)) (not (< ?v_97 0))) (<= ?v_97 11)) (not (< ?v_98 0))) (<= ?v_98 11)) (not (< ?v_99 1))) (<= ?v_99 4)) (not (< ?v_100 1))) (<= ?v_100 4)) (not (< ?v_101 1))) (<= ?v_101 4)) (not (< ?v_102 1))) (<= ?v_102 4)) (not (< ?v_103 1))) (<= ?v_103 4)) (not (< ?v_104 1))) (<= ?v_104 4)) (not (< ?v_105 1))) (<= ?v_105 4)) (not (< ?v_106 1))) (<= ?v_106 4)) (not (< ?v_107 1))) (<= ?v_107 4)) (not (< ?v_108 1))) (<= ?v_108 4)) (not (< ?v_109 1))) (<= ?v_109 4)) (not (< ?v_110 1))) (<= ?v_110 4)) (not (< ?v_111 0))) (<= ?v_111 11)) (not (< ?v_112 0))) (<= ?v_112 11)) (not (< ?v_113 1))) (<= ?v_113 4)) (not (< ?v_114 1))) (<= ?v_114 4)) (not (< ?v_115 1))) (<= ?v_115 4)) (not (< ?v_116 1))) (<= ?v_116 4)) (not (< ?v_117 1))) (<= ?v_117 4)) (not (< ?v_118 1))) (<= ?v_118 4)) (not (< ?v_119 1))) (<= ?v_119 4)) (not (< ?v_120 1))) (<= ?v_120 4)) (not (< ?v_121 1))) (<= ?v_121 4)) (not (< ?v_122 1))) (<= ?v_122 4)) (not (< ?v_123 1))) (<= ?v_123 4)) (not (< ?v_124 1))) (<= ?v_124 4)) (not (< ?v_125 0))) (<= ?v_125 11)) (not (< ?v_126 0))) (<= ?v_126 11)) (not (< ?v_127 1))) (<= ?v_127 4)) (not (< ?v_128 1))) (<= ?v_128 4)) (not (< ?v_129 1))) (<= ?v_129 4)) (not (< ?v_130 1))) (<= ?v_130 4)) (not (< ?v_131 1))) (<= ?v_131 4)) (not (< ?v_132 1))) (<= ?v_132 4)) (not (< ?v_133 1))) (<= ?v_133 4)) (not (< ?v_134 1))) (<= ?v_134 4)) (not (< ?v_135 1))) (<= ?v_135 4)) (not (< ?v_136 1))) (<= ?v_136 4)) (not (< ?v_137 1))) (<= ?v_137 4)) (not (< ?v_138 1))) (<= ?v_138 4)) (not (< ?v_139 0))) (<= ?v_139 11)) (and ?v_980 ?v_981)) (and ?v_987 ?v_988)) (and ?v_1000 ?v_1001)) (and ?v_1006 ?v_1007)) (and ?v_1012 ?v_1013)) (and ?v_1042 ?v_1043)) (and ?v_1062 ?v_1063)) (and ?v_1066 ?v_1067)) (and x_16 x_17)) (and x_18 x_19)) (and x_20 x_21)) (and x_22 x_23)) (and ?v_1014 ?v_1015)) (and ?v_1044 ?v_1045)) (and ?v_1064 ?v_1065)) (and ?v_1068 ?v_1069)) (= ?v_0 1)) (= ?v_1 1)) (= ?v_2 1)) (= ?v_3 1)) (= ?v_4 1)) (= ?v_5 1)) (= ?v_6 1)) (= ?v_7 1)) (= ?v_8 1)) (= ?v_9 1)) (= ?v_10 1)) (= ?v_11 1)) ?v_140) (= ?v_13 0)) (= (- x_47 x_45) 1)) (ite (= ?v_12 11) (= (- x_78 x_43) 0) (ite (= ?v_12 10) (= (- x_78 x_42) 0) (ite (= ?v_12 9) (= (- x_78 x_41) 0) (ite (= ?v_12 8) (= (- x_78 x_40) 0) (ite (= ?v_12 7) (= (- x_78 x_39) 0) (ite (= ?v_12 6) (= (- x_78 x_38) 0) (ite (= ?v_12 5) (= (- x_78 x_37) 0) (ite (= ?v_12 4) (= (- x_78 x_36) 0) (ite (= ?v_12 3) (= (- x_78 x_35) 0) (ite (= ?v_12 2) (= (- x_78 x_34) 0) (ite ?v_140 (= (- x_78 x_33) 0) (= (- x_78 x_32) 0))))))))))))) (= (- x_102 x_46) 1)) (ite (= ?v_27 11) (= (- x_133 x_67) 0) (ite (= ?v_27 10) (= (- x_133 x_66) 0) (ite (= ?v_27 9) (= (- x_133 x_65) 0) (ite (= ?v_27 8) (= (- x_133 x_64) 0) (ite (= ?v_27 7) (= (- x_133 x_63) 0) (ite (= ?v_27 6) (= (- x_133 x_62) 0) (ite (= ?v_27 5) (= (- x_133 x_61) 0) (ite (= ?v_27 4) (= (- x_133 x_60) 0) (ite (= ?v_27 3) (= (- x_133 x_59) 0) (ite (= ?v_27 2) (= (- x_133 x_58) 0) (ite ?v_1078 (= (- x_133 x_57) 0) (= (- x_133 x_56) 0))))))))))))) (= (- x_157 x_101) 1)) (ite (= ?v_41 11) (= (- x_188 x_122) 0) (ite (= ?v_41 10) (= (- x_188 x_121) 0) (ite (= ?v_41 9) (= (- x_188 x_120) 0) (ite (= ?v_41 8) (= (- x_188 x_119) 0) (ite (= ?v_41 7) (= (- x_188 x_118) 0) (ite (= ?v_41 6) (= (- x_188 x_117) 0) (ite (= ?v_41 5) (= (- x_188 x_116) 0) (ite (= ?v_41 4) (= (- x_188 x_115) 0) (ite (= ?v_41 3) (= (- x_188 x_114) 0) (ite (= ?v_41 2) (= (- x_188 x_113) 0) (ite ?v_977 (= (- x_188 x_112) 0) (= (- x_188 x_111) 0))))))))))))) (= (- x_212 x_156) 1)) (ite (= ?v_55 11) (= (- x_243 x_177) 0) (ite (= ?v_55 10) (= (- x_243 x_176) 0) (ite (= ?v_55 9) (= (- x_243 x_175) 0) (ite (= ?v_55 8) (= (- x_243 x_174) 0) (ite (= ?v_55 7) (= (- x_243 x_173) 0) (ite (= ?v_55 6) (= (- x_243 x_172) 0) (ite (= ?v_55 5) (= (- x_243 x_171) 0) (ite (= ?v_55 4) (= (- x_243 x_170) 0) (ite (= ?v_55 3) (= (- x_243 x_169) 0) (ite (= ?v_55 2) (= (- x_243 x_168) 0) (ite ?v_876 (= (- x_243 x_167) 0) (= (- x_243 x_166) 0))))))))))))) (= (- x_267 x_211) 1)) (ite (= ?v_69 11) (= (- x_298 x_232) 0) (ite (= ?v_69 10) (= (- x_298 x_231) 0) (ite (= ?v_69 9) (= (- x_298 x_230) 0) (ite (= ?v_69 8) (= (- x_298 x_229) 0) (ite (= ?v_69 7) (= (- x_298 x_228) 0) (ite (= ?v_69 6) (= (- x_298 x_227) 0) (ite (= ?v_69 5) (= (- x_298 x_226) 0) (ite (= ?v_69 4) (= (- x_298 x_225) 0) (ite (= ?v_69 3) (= (- x_298 x_224) 0) (ite (= ?v_69 2) (= (- x_298 x_223) 0) (ite ?v_775 (= (- x_298 x_222) 0) (= (- x_298 x_221) 0))))))))))))) (= (- x_322 x_266) 1)) (ite (= ?v_83 11) (= (- x_353 x_287) 0) (ite (= ?v_83 10) (= (- x_353 x_286) 0) (ite (= ?v_83 9) (= (- x_353 x_285) 0) (ite (= ?v_83 8) (= (- x_353 x_284) 0) (ite (= ?v_83 7) (= (- x_353 x_283) 0) (ite (= ?v_83 6) (= (- x_353 x_282) 0) (ite (= ?v_83 5) (= (- x_353 x_281) 0) (ite (= ?v_83 4) (= (- x_353 x_280) 0) (ite (= ?v_83 3) (= (- x_353 x_279) 0) (ite (= ?v_83 2) (= (- x_353 x_278) 0) (ite ?v_674 (= (- x_353 x_277) 0) (= (- x_353 x_276) 0))))))))))))) (= (- x_377 x_321) 1)) (ite (= ?v_97 11) (= (- x_408 x_342) 0) (ite (= ?v_97 10) (= (- x_408 x_341) 0) (ite (= ?v_97 9) (= (- x_408 x_340) 0) (ite (= ?v_97 8) (= (- x_408 x_339) 0) (ite (= ?v_97 7) (= (- x_408 x_338) 0) (ite (= ?v_97 6) (= (- x_408 x_337) 0) (ite (= ?v_97 5) (= (- x_408 x_336) 0) (ite (= ?v_97 4) (= (- x_408 x_335) 0) (ite (= ?v_97 3) (= (- x_408 x_334) 0) (ite (= ?v_97 2) (= (- x_408 x_333) 0) (ite ?v_573 (= (- x_408 x_332) 0) (= (- x_408 x_331) 0))))))))))))) (= (- x_432 x_376) 1)) (ite (= ?v_111 11) (= (- x_463 x_397) 0) (ite (= ?v_111 10) (= (- x_463 x_396) 0) (ite (= ?v_111 9) (= (- x_463 x_395) 0) (ite (= ?v_111 8) (= (- x_463 x_394) 0) (ite (= ?v_111 7) (= (- x_463 x_393) 0) (ite (= ?v_111 6) (= (- x_463 x_392) 0) (ite (= ?v_111 5) (= (- x_463 x_391) 0) (ite (= ?v_111 4) (= (- x_463 x_390) 0) (ite (= ?v_111 3) (= (- x_463 x_389) 0) (ite (= ?v_111 2) (= (- x_463 x_388) 0) (ite ?v_472 (= (- x_463 x_387) 0) (= (- x_463 x_386) 0))))))))))))) (= (- x_487 x_431) 1)) (ite (= ?v_125 11) (= (- x_518 x_452) 0) (ite (= ?v_125 10) (= (- x_518 x_451) 0) (ite (= ?v_125 9) (= (- x_518 x_450) 0) (ite (= ?v_125 8) (= (- x_518 x_449) 0) (ite (= ?v_125 7) (= (- x_518 x_448) 0) (ite (= ?v_125 6) (= (- x_518 x_447) 0) (ite (= ?v_125 5) (= (- x_518 x_446) 0) (ite (= ?v_125 4) (= (- x_518 x_445) 0) (ite (= ?v_125 3) (= (- x_518 x_444) 0) (ite (= ?v_125 2) (= (- x_518 x_443) 0) (ite ?v_371 (= (- x_518 x_442) 0) (= (- x_518 x_441) 0))))))))))))) (or (and (and (and (and (and (and (= ?v_187 0) (or (or (or (and (and (and (and (and (and (and (= ?v_150 1) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_144) ?v_142) ?v_145) ?v_143) x_519) ?v_147) x_527) ?v_149) (and (and (and (and (and (and (and ?v_152 x_464) ?v_142) x_433) ?v_143) ?v_146) x_520) ?v_164)) (and (and (and (and (and (and ?v_156 ?v_144) x_465) x_519) x_520) ?v_148) x_528)) (and (and (and (and (and (and (and (and ?v_158 x_464) x_465) ?v_145) x_434) ?v_146) ?v_147) ?v_148) ?v_149))) ?v_178) ?v_155) ?v_165) ?v_166) ?v_167) ?v_168) (and (and (and (and (and (and (and (= ?v_150 2) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_157) ?v_153) ?v_159) ?v_154) x_521) ?v_161) x_529) ?v_163) (and (and (and (and (and (and (and ?v_152 x_466) ?v_153) x_435) ?v_154) ?v_160) x_522) ?v_155)) (and (and (and (and (and (and ?v_156 ?v_157) x_467) x_521) x_522) ?v_162) x_530)) (and (and (and (and (and (and (and (and ?v_158 x_466) x_467) ?v_159) x_436) ?v_160) ?v_161) ?v_162) ?v_163))) ?v_177) ?v_164) ?v_165) ?v_166) ?v_167) ?v_168)) (and (and (and (and (and (and (and (= ?v_150 3) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_171) ?v_169) ?v_172) ?v_170) x_523) ?v_174) x_531) ?v_176) (and (and (and (and (and (and (and ?v_152 x_468) ?v_169) x_437) ?v_170) ?v_173) x_524) ?v_166)) (and (and (and (and (and (and ?v_156 ?v_171) x_469) x_523) x_524) ?v_175) x_532)) (and (and (and (and (and (and (and (and ?v_158 x_468) x_469) ?v_172) x_438) ?v_173) ?v_174) ?v_175) ?v_176))) ?v_177) ?v_164) ?v_178) ?v_155) ?v_167) ?v_168)) (and (and (and (and (and (and (and (= ?v_150 4) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_181) ?v_179) ?v_182) ?v_180) x_525) ?v_184) x_533) ?v_186) (and (and (and (and (and (and (and ?v_152 x_470) ?v_179) x_439) ?v_180) ?v_183) x_526) ?v_168)) (and (and (and (and (and (and ?v_156 ?v_181) x_471) x_525) x_526) ?v_185) x_534)) (and (and (and (and (and (and (and (and ?v_158 x_470) x_471) ?v_182) x_440) ?v_183) ?v_184) ?v_185) ?v_186))) ?v_177) ?v_164) ?v_178) ?v_155) ?v_165) ?v_166))) ?v_233) ?v_188) ?v_232) ?v_272) ?v_271) (and (and (and (and (and (and (and (and (and (= ?v_187 1) (or (or (or (and (and (and (and (= ?v_231 0) (not ?v_270)) (= (- x_486 x_487) 0)) ?v_188) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 1) ?v_249) ?v_234) ?v_250) ?v_235) (ite ?v_215 (= ?v_127 1) ?v_189)) (ite ?v_216 (= ?v_128 1) ?v_191)) (ite ?v_217 (= ?v_129 1) ?v_192)) (ite ?v_218 (= ?v_130 1) ?v_193)) (ite ?v_219 (= ?v_131 1) ?v_194)) (ite ?v_220 (= ?v_132 1) ?v_195)) (ite ?v_221 (= ?v_133 1) ?v_196)) (ite ?v_222 (= ?v_134 1) ?v_197)) (ite ?v_223 (= ?v_135 1) ?v_198)) (ite ?v_224 (= ?v_136 1) ?v_199)) (ite ?v_225 (= ?v_137 1) ?v_200)) (ite ?v_226 (= ?v_138 1) ?v_201)) x_508) ?v_252) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207) ?v_253) ?v_236) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 2) ?v_255) ?v_238) ?v_256) ?v_239) (ite ?v_215 (= ?v_127 2) ?v_189)) (ite ?v_216 (= ?v_128 2) ?v_191)) (ite ?v_217 (= ?v_129 2) ?v_192)) (ite ?v_218 (= ?v_130 2) ?v_193)) (ite ?v_219 (= ?v_131 2) ?v_194)) (ite ?v_220 (= ?v_132 2) ?v_195)) (ite ?v_221 (= ?v_133 2) ?v_196)) (ite ?v_222 (= ?v_134 2) ?v_197)) (ite ?v_223 (= ?v_135 2) ?v_198)) (ite ?v_224 (= ?v_136 2) ?v_199)) (ite ?v_225 (= ?v_137 2) ?v_200)) (ite ?v_226 (= ?v_138 2) ?v_201)) ?v_227) ?v_228) x_510) ?v_258) ?v_204) ?v_205) ?v_206) ?v_207) ?v_229) ?v_230) ?v_259) ?v_241) ?v_210) ?v_211) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 3) ?v_260) ?v_242) ?v_261) ?v_243) (ite ?v_215 (= ?v_127 3) ?v_189)) (ite ?v_216 (= ?v_128 3) ?v_191)) (ite ?v_217 (= ?v_129 3) ?v_192)) (ite ?v_218 (= ?v_130 3) ?v_193)) (ite ?v_219 (= ?v_131 3) ?v_194)) (ite ?v_220 (= ?v_132 3) ?v_195)) (ite ?v_221 (= ?v_133 3) ?v_196)) (ite ?v_222 (= ?v_134 3) ?v_197)) (ite ?v_223 (= ?v_135 3) ?v_198)) (ite ?v_224 (= ?v_136 3) ?v_199)) (ite ?v_225 (= ?v_137 3) ?v_200)) (ite ?v_226 (= ?v_138 3) ?v_201)) ?v_227) ?v_228) ?v_202) ?v_203) x_512) ?v_263) ?v_206) ?v_207) ?v_229) ?v_230) ?v_208) ?v_209) ?v_264) ?v_244) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 4) ?v_265) ?v_245) ?v_266) ?v_246) (ite ?v_215 (= ?v_127 4) ?v_189)) (ite ?v_216 (= ?v_128 4) ?v_191)) (ite ?v_217 (= ?v_129 4) ?v_192)) (ite ?v_218 (= ?v_130 4) ?v_193)) (ite ?v_219 (= ?v_131 4) ?v_194)) (ite ?v_220 (= ?v_132 4) ?v_195)) (ite ?v_221 (= ?v_133 4) ?v_196)) (ite ?v_222 (= ?v_134 4) ?v_197)) (ite ?v_223 (= ?v_135 4) ?v_198)) (ite ?v_224 (= ?v_136 4) ?v_199)) (ite ?v_225 (= ?v_137 4) ?v_200)) (ite ?v_226 (= ?v_138 4) ?v_201)) ?v_227) ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) x_514) ?v_268) ?v_229) ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) ?v_269) ?v_247))) (and (and (and (and (= ?v_231 1) ?v_232) ?v_188) ?v_233) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 1) x_472) ?v_234) x_453) ?v_235) (= ?v_240 1)) ?v_251) x_509) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207) x_488) ?v_236) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 2) x_474) ?v_238) x_455) ?v_239) (= ?v_240 2)) ?v_227) ?v_228) ?v_257) x_511) ?v_204) ?v_205) ?v_206) ?v_207) ?v_229) ?v_230) x_490) ?v_241) ?v_210) ?v_211) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 3) x_476) ?v_242) x_457) ?v_243) (= ?v_240 3)) ?v_227) ?v_228) ?v_202) ?v_203) ?v_262) x_513) ?v_206) ?v_207) ?v_229) ?v_230) ?v_208) ?v_209) x_492) ?v_244) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 4) x_478) ?v_245) x_459) ?v_246) (= ?v_240 4)) ?v_227) ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) ?v_267) x_515) ?v_229) ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) x_494) ?v_247)))) (and (and (and (and (= ?v_231 2) (= ?v_248 1)) ?v_232) ?v_233) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 1) ?v_249) x_473) ?v_250) x_454) ?v_251) ?v_252) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207) ?v_253) x_489) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 2) ?v_255) x_475) ?v_256) x_456) ?v_227) ?v_228) ?v_257) ?v_258) ?v_204) ?v_205) ?v_206) ?v_207) ?v_229) ?v_230) ?v_259) x_491) ?v_210) ?v_211) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 3) ?v_260) x_477) ?v_261) x_458) ?v_227) ?v_228) ?v_202) ?v_203) ?v_262) ?v_263) ?v_206) ?v_207) ?v_229) ?v_230) ?v_208) ?v_209) ?v_264) x_493) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 4) ?v_265) x_479) ?v_266) x_460) ?v_227) ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) ?v_267) ?v_268) ?v_229) ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) ?v_269) x_495)))) (and (and (and (and (and (and (and (= ?v_231 3) (= (- x_462 x_487) 0)) ?v_270) (= ?v_139 1)) (= ?v_126 0)) ?v_271) ?v_232) ?v_272))) ?v_177) ?v_178) ?v_165) ?v_167) ?v_164) ?v_155) ?v_166) ?v_168))) (or (and (and (and (and (and (and (= ?v_303 0) (or (or (or (and (and (and (and (and (and (and (= ?v_278 1) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_276) ?v_274) ?v_277) ?v_275) x_464) ?v_142) x_472) ?v_234) (and (and (and (and (and (and (and ?v_280 x_409) ?v_274) x_378) ?v_275) ?v_144) x_465) ?v_288)) (and (and (and (and (and (and ?v_284 ?v_276) x_410) x_464) x_465) ?v_249) x_473)) (and (and (and (and (and (and (and (and ?v_286 x_409) x_410) ?v_277) x_379) ?v_144) ?v_142) ?v_249) ?v_234))) ?v_298) ?v_283) ?v_289) ?v_290) ?v_291) ?v_292) (and (and (and (and (and (and (and (= ?v_278 2) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_285) ?v_281) ?v_287) ?v_282) x_466) ?v_153) x_474) ?v_238) (and (and (and (and (and (and (and ?v_280 x_411) ?v_281) x_380) ?v_282) ?v_157) x_467) ?v_283)) (and (and (and (and (and (and ?v_284 ?v_285) x_412) x_466) x_467) ?v_255) x_475)) (and (and (and (and (and (and (and (and ?v_286 x_411) x_412) ?v_287) x_381) ?v_157) ?v_153) ?v_255) ?v_238))) ?v_297) ?v_288) ?v_289) ?v_290) ?v_291) ?v_292)) (and (and (and (and (and (and (and (= ?v_278 3) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_295) ?v_293) ?v_296) ?v_294) x_468) ?v_169) x_476) ?v_242) (and (and (and (and (and (and (and ?v_280 x_413) ?v_293) x_382) ?v_294) ?v_171) x_469) ?v_290)) (and (and (and (and (and (and ?v_284 ?v_295) x_414) x_468) x_469) ?v_260) x_477)) (and (and (and (and (and (and (and (and ?v_286 x_413) x_414) ?v_296) x_383) ?v_171) ?v_169) ?v_260) ?v_242))) ?v_297) ?v_288) ?v_298) ?v_283) ?v_291) ?v_292)) (and (and (and (and (and (and (and (= ?v_278 4) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_301) ?v_299) ?v_302) ?v_300) x_470) ?v_179) x_478) ?v_245) (and (and (and (and (and (and (and ?v_280 x_415) ?v_299) x_384) ?v_300) ?v_181) x_471) ?v_292)) (and (and (and (and (and (and ?v_284 ?v_301) x_416) x_470) x_471) ?v_265) x_479)) (and (and (and (and (and (and (and (and ?v_286 x_415) x_416) ?v_302) x_385) ?v_181) ?v_179) ?v_265) ?v_245))) ?v_297) ?v_288) ?v_298) ?v_283) ?v_289) ?v_290))) ?v_349) ?v_304) ?v_348) ?v_373) ?v_372) (and (and (and (and (and (and (and (and (and (= ?v_303 1) (or (or (or (and (and (and (and (= ?v_347 0) (not ?v_370)) (= (- x_431 x_432) 0)) ?v_304) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 1) ?v_361) ?v_350) ?v_362) ?v_351) (ite ?v_331 (= ?v_113 1) ?v_305)) (ite ?v_332 (= ?v_114 1) ?v_307)) (ite ?v_333 (= ?v_115 1) ?v_308)) (ite ?v_334 (= ?v_116 1) ?v_309)) (ite ?v_335 (= ?v_117 1) ?v_310)) (ite ?v_336 (= ?v_118 1) ?v_311)) (ite ?v_337 (= ?v_119 1) ?v_312)) (ite ?v_338 (= ?v_120 1) ?v_313)) (ite ?v_339 (= ?v_121 1) ?v_314)) (ite ?v_340 (= ?v_122 1) ?v_315)) (ite ?v_341 (= ?v_123 1) ?v_316)) (ite ?v_342 (= ?v_124 1) ?v_317)) x_453) ?v_235) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323) ?v_145) ?v_143) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 2) ?v_364) ?v_353) ?v_365) ?v_354) (ite ?v_331 (= ?v_113 2) ?v_305)) (ite ?v_332 (= ?v_114 2) ?v_307)) (ite ?v_333 (= ?v_115 2) ?v_308)) (ite ?v_334 (= ?v_116 2) ?v_309)) (ite ?v_335 (= ?v_117 2) ?v_310)) (ite ?v_336 (= ?v_118 2) ?v_311)) (ite ?v_337 (= ?v_119 2) ?v_312)) (ite ?v_338 (= ?v_120 2) ?v_313)) (ite ?v_339 (= ?v_121 2) ?v_314)) (ite ?v_340 (= ?v_122 2) ?v_315)) (ite ?v_341 (= ?v_123 2) ?v_316)) (ite ?v_342 (= ?v_124 2) ?v_317)) ?v_343) ?v_344) x_455) ?v_239) ?v_320) ?v_321) ?v_322) ?v_323) ?v_345) ?v_346) ?v_159) ?v_154) ?v_326) ?v_327) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 3) ?v_366) ?v_356) ?v_367) ?v_357) (ite ?v_331 (= ?v_113 3) ?v_305)) (ite ?v_332 (= ?v_114 3) ?v_307)) (ite ?v_333 (= ?v_115 3) ?v_308)) (ite ?v_334 (= ?v_116 3) ?v_309)) (ite ?v_335 (= ?v_117 3) ?v_310)) (ite ?v_336 (= ?v_118 3) ?v_311)) (ite ?v_337 (= ?v_119 3) ?v_312)) (ite ?v_338 (= ?v_120 3) ?v_313)) (ite ?v_339 (= ?v_121 3) ?v_314)) (ite ?v_340 (= ?v_122 3) ?v_315)) (ite ?v_341 (= ?v_123 3) ?v_316)) (ite ?v_342 (= ?v_124 3) ?v_317)) ?v_343) ?v_344) ?v_318) ?v_319) x_457) ?v_243) ?v_322) ?v_323) ?v_345) ?v_346) ?v_324) ?v_325) ?v_172) ?v_170) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 4) ?v_368) ?v_358) ?v_369) ?v_359) (ite ?v_331 (= ?v_113 4) ?v_305)) (ite ?v_332 (= ?v_114 4) ?v_307)) (ite ?v_333 (= ?v_115 4) ?v_308)) (ite ?v_334 (= ?v_116 4) ?v_309)) (ite ?v_335 (= ?v_117 4) ?v_310)) (ite ?v_336 (= ?v_118 4) ?v_311)) (ite ?v_337 (= ?v_119 4) ?v_312)) (ite ?v_338 (= ?v_120 4) ?v_313)) (ite ?v_339 (= ?v_121 4) ?v_314)) (ite ?v_340 (= ?v_122 4) ?v_315)) (ite ?v_341 (= ?v_123 4) ?v_316)) (ite ?v_342 (= ?v_124 4) ?v_317)) ?v_343) ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) x_459) ?v_246) ?v_345) ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) ?v_182) ?v_180))) (and (and (and (and (= ?v_347 1) ?v_348) ?v_304) ?v_349) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 1) x_417) ?v_350) x_398) ?v_351) (= ?v_355 1)) ?v_250) x_454) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323) x_433) ?v_143) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 2) x_419) ?v_353) x_400) ?v_354) (= ?v_355 2)) ?v_343) ?v_344) ?v_256) x_456) ?v_320) ?v_321) ?v_322) ?v_323) ?v_345) ?v_346) x_435) ?v_154) ?v_326) ?v_327) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 3) x_421) ?v_356) x_402) ?v_357) (= ?v_355 3)) ?v_343) ?v_344) ?v_318) ?v_319) ?v_261) x_458) ?v_322) ?v_323) ?v_345) ?v_346) ?v_324) ?v_325) x_437) ?v_170) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 4) x_423) ?v_358) x_404) ?v_359) (= ?v_355 4)) ?v_343) ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) ?v_266) x_460) ?v_345) ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) x_439) ?v_180)))) (and (and (and (and (= ?v_347 2) (= ?v_360 1)) ?v_348) ?v_349) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 1) ?v_361) x_418) ?v_362) x_399) ?v_250) ?v_235) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323) ?v_145) x_434) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 2) ?v_364) x_420) ?v_365) x_401) ?v_343) ?v_344) ?v_256) ?v_239) ?v_320) ?v_321) ?v_322) ?v_323) ?v_345) ?v_346) ?v_159) x_436) ?v_326) ?v_327) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 3) ?v_366) x_422) ?v_367) x_403) ?v_343) ?v_344) ?v_318) ?v_319) ?v_261) ?v_243) ?v_322) ?v_323) ?v_345) ?v_346) ?v_324) ?v_325) ?v_172) x_438) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 4) ?v_368) x_424) ?v_369) x_405) ?v_343) ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) ?v_266) ?v_246) ?v_345) ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) ?v_182) x_440)))) (and (and (and (and (and (and (and (= ?v_347 3) (= (- x_407 x_432) 0)) ?v_370) ?v_371) (= ?v_112 0)) ?v_372) ?v_348) ?v_373))) ?v_297) ?v_298) ?v_289) ?v_291) ?v_288) ?v_283) ?v_290) ?v_292))) (or (and (and (and (and (and (and (= ?v_404 0) (or (or (or (and (and (and (and (and (and (and (= ?v_379 1) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_377) ?v_375) ?v_378) ?v_376) x_409) ?v_274) x_417) ?v_350) (and (and (and (and (and (and (and ?v_381 x_354) ?v_375) x_323) ?v_376) ?v_276) x_410) ?v_389)) (and (and (and (and (and (and ?v_385 ?v_377) x_355) x_409) x_410) ?v_361) x_418)) (and (and (and (and (and (and (and (and ?v_387 x_354) x_355) ?v_378) x_324) ?v_276) ?v_274) ?v_361) ?v_350))) ?v_399) ?v_384) ?v_390) ?v_391) ?v_392) ?v_393) (and (and (and (and (and (and (and (= ?v_379 2) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_386) ?v_382) ?v_388) ?v_383) x_411) ?v_281) x_419) ?v_353) (and (and (and (and (and (and (and ?v_381 x_356) ?v_382) x_325) ?v_383) ?v_285) x_412) ?v_384)) (and (and (and (and (and (and ?v_385 ?v_386) x_357) x_411) x_412) ?v_364) x_420)) (and (and (and (and (and (and (and (and ?v_387 x_356) x_357) ?v_388) x_326) ?v_285) ?v_281) ?v_364) ?v_353))) ?v_398) ?v_389) ?v_390) ?v_391) ?v_392) ?v_393)) (and (and (and (and (and (and (and (= ?v_379 3) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_396) ?v_394) ?v_397) ?v_395) x_413) ?v_293) x_421) ?v_356) (and (and (and (and (and (and (and ?v_381 x_358) ?v_394) x_327) ?v_395) ?v_295) x_414) ?v_391)) (and (and (and (and (and (and ?v_385 ?v_396) x_359) x_413) x_414) ?v_366) x_422)) (and (and (and (and (and (and (and (and ?v_387 x_358) x_359) ?v_397) x_328) ?v_295) ?v_293) ?v_366) ?v_356))) ?v_398) ?v_389) ?v_399) ?v_384) ?v_392) ?v_393)) (and (and (and (and (and (and (and (= ?v_379 4) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_402) ?v_400) ?v_403) ?v_401) x_415) ?v_299) x_423) ?v_358) (and (and (and (and (and (and (and ?v_381 x_360) ?v_400) x_329) ?v_401) ?v_301) x_416) ?v_393)) (and (and (and (and (and (and ?v_385 ?v_402) x_361) x_415) x_416) ?v_368) x_424)) (and (and (and (and (and (and (and (and ?v_387 x_360) x_361) ?v_403) x_330) ?v_301) ?v_299) ?v_368) ?v_358))) ?v_398) ?v_389) ?v_399) ?v_384) ?v_390) ?v_391))) ?v_450) ?v_405) ?v_449) ?v_474) ?v_473) (and (and (and (and (and (and (and (and (and (= ?v_404 1) (or (or (or (and (and (and (and (= ?v_448 0) (not ?v_471)) (= (- x_376 x_377) 0)) ?v_405) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 1) ?v_462) ?v_451) ?v_463) ?v_452) (ite ?v_432 (= ?v_99 1) ?v_406)) (ite ?v_433 (= ?v_100 1) ?v_408)) (ite ?v_434 (= ?v_101 1) ?v_409)) (ite ?v_435 (= ?v_102 1) ?v_410)) (ite ?v_436 (= ?v_103 1) ?v_411)) (ite ?v_437 (= ?v_104 1) ?v_412)) (ite ?v_438 (= ?v_105 1) ?v_413)) (ite ?v_439 (= ?v_106 1) ?v_414)) (ite ?v_440 (= ?v_107 1) ?v_415)) (ite ?v_441 (= ?v_108 1) ?v_416)) (ite ?v_442 (= ?v_109 1) ?v_417)) (ite ?v_443 (= ?v_110 1) ?v_418)) x_398) ?v_351) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424) ?v_277) ?v_275) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 2) ?v_465) ?v_454) ?v_466) ?v_455) (ite ?v_432 (= ?v_99 2) ?v_406)) (ite ?v_433 (= ?v_100 2) ?v_408)) (ite ?v_434 (= ?v_101 2) ?v_409)) (ite ?v_435 (= ?v_102 2) ?v_410)) (ite ?v_436 (= ?v_103 2) ?v_411)) (ite ?v_437 (= ?v_104 2) ?v_412)) (ite ?v_438 (= ?v_105 2) ?v_413)) (ite ?v_439 (= ?v_106 2) ?v_414)) (ite ?v_440 (= ?v_107 2) ?v_415)) (ite ?v_441 (= ?v_108 2) ?v_416)) (ite ?v_442 (= ?v_109 2) ?v_417)) (ite ?v_443 (= ?v_110 2) ?v_418)) ?v_444) ?v_445) x_400) ?v_354) ?v_421) ?v_422) ?v_423) ?v_424) ?v_446) ?v_447) ?v_287) ?v_282) ?v_427) ?v_428) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 3) ?v_467) ?v_457) ?v_468) ?v_458) (ite ?v_432 (= ?v_99 3) ?v_406)) (ite ?v_433 (= ?v_100 3) ?v_408)) (ite ?v_434 (= ?v_101 3) ?v_409)) (ite ?v_435 (= ?v_102 3) ?v_410)) (ite ?v_436 (= ?v_103 3) ?v_411)) (ite ?v_437 (= ?v_104 3) ?v_412)) (ite ?v_438 (= ?v_105 3) ?v_413)) (ite ?v_439 (= ?v_106 3) ?v_414)) (ite ?v_440 (= ?v_107 3) ?v_415)) (ite ?v_441 (= ?v_108 3) ?v_416)) (ite ?v_442 (= ?v_109 3) ?v_417)) (ite ?v_443 (= ?v_110 3) ?v_418)) ?v_444) ?v_445) ?v_419) ?v_420) x_402) ?v_357) ?v_423) ?v_424) ?v_446) ?v_447) ?v_425) ?v_426) ?v_296) ?v_294) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 4) ?v_469) ?v_459) ?v_470) ?v_460) (ite ?v_432 (= ?v_99 4) ?v_406)) (ite ?v_433 (= ?v_100 4) ?v_408)) (ite ?v_434 (= ?v_101 4) ?v_409)) (ite ?v_435 (= ?v_102 4) ?v_410)) (ite ?v_436 (= ?v_103 4) ?v_411)) (ite ?v_437 (= ?v_104 4) ?v_412)) (ite ?v_438 (= ?v_105 4) ?v_413)) (ite ?v_439 (= ?v_106 4) ?v_414)) (ite ?v_440 (= ?v_107 4) ?v_415)) (ite ?v_441 (= ?v_108 4) ?v_416)) (ite ?v_442 (= ?v_109 4) ?v_417)) (ite ?v_443 (= ?v_110 4) ?v_418)) ?v_444) ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) x_404) ?v_359) ?v_446) ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) ?v_302) ?v_300))) (and (and (and (and (= ?v_448 1) ?v_449) ?v_405) ?v_450) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 1) x_362) ?v_451) x_343) ?v_452) (= ?v_456 1)) ?v_362) x_399) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424) x_378) ?v_275) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 2) x_364) ?v_454) x_345) ?v_455) (= ?v_456 2)) ?v_444) ?v_445) ?v_365) x_401) ?v_421) ?v_422) ?v_423) ?v_424) ?v_446) ?v_447) x_380) ?v_282) ?v_427) ?v_428) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 3) x_366) ?v_457) x_347) ?v_458) (= ?v_456 3)) ?v_444) ?v_445) ?v_419) ?v_420) ?v_367) x_403) ?v_423) ?v_424) ?v_446) ?v_447) ?v_425) ?v_426) x_382) ?v_294) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 4) x_368) ?v_459) x_349) ?v_460) (= ?v_456 4)) ?v_444) ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) ?v_369) x_405) ?v_446) ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) x_384) ?v_300)))) (and (and (and (and (= ?v_448 2) (= ?v_461 1)) ?v_449) ?v_450) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 1) ?v_462) x_363) ?v_463) x_344) ?v_362) ?v_351) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424) ?v_277) x_379) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 2) ?v_465) x_365) ?v_466) x_346) ?v_444) ?v_445) ?v_365) ?v_354) ?v_421) ?v_422) ?v_423) ?v_424) ?v_446) ?v_447) ?v_287) x_381) ?v_427) ?v_428) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 3) ?v_467) x_367) ?v_468) x_348) ?v_444) ?v_445) ?v_419) ?v_420) ?v_367) ?v_357) ?v_423) ?v_424) ?v_446) ?v_447) ?v_425) ?v_426) ?v_296) x_383) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 4) ?v_469) x_369) ?v_470) x_350) ?v_444) ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) ?v_369) ?v_359) ?v_446) ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) ?v_302) x_385)))) (and (and (and (and (and (and (and (= ?v_448 3) (= (- x_352 x_377) 0)) ?v_471) ?v_472) (= ?v_98 0)) ?v_473) ?v_449) ?v_474))) ?v_398) ?v_399) ?v_390) ?v_392) ?v_389) ?v_384) ?v_391) ?v_393))) (or (and (and (and (and (and (and (= ?v_505 0) (or (or (or (and (and (and (and (and (and (and (= ?v_480 1) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_478) ?v_476) ?v_479) ?v_477) x_354) ?v_375) x_362) ?v_451) (and (and (and (and (and (and (and ?v_482 x_299) ?v_476) x_268) ?v_477) ?v_377) x_355) ?v_490)) (and (and (and (and (and (and ?v_486 ?v_478) x_300) x_354) x_355) ?v_462) x_363)) (and (and (and (and (and (and (and (and ?v_488 x_299) x_300) ?v_479) x_269) ?v_377) ?v_375) ?v_462) ?v_451))) ?v_500) ?v_485) ?v_491) ?v_492) ?v_493) ?v_494) (and (and (and (and (and (and (and (= ?v_480 2) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_487) ?v_483) ?v_489) ?v_484) x_356) ?v_382) x_364) ?v_454) (and (and (and (and (and (and (and ?v_482 x_301) ?v_483) x_270) ?v_484) ?v_386) x_357) ?v_485)) (and (and (and (and (and (and ?v_486 ?v_487) x_302) x_356) x_357) ?v_465) x_365)) (and (and (and (and (and (and (and (and ?v_488 x_301) x_302) ?v_489) x_271) ?v_386) ?v_382) ?v_465) ?v_454))) ?v_499) ?v_490) ?v_491) ?v_492) ?v_493) ?v_494)) (and (and (and (and (and (and (and (= ?v_480 3) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_497) ?v_495) ?v_498) ?v_496) x_358) ?v_394) x_366) ?v_457) (and (and (and (and (and (and (and ?v_482 x_303) ?v_495) x_272) ?v_496) ?v_396) x_359) ?v_492)) (and (and (and (and (and (and ?v_486 ?v_497) x_304) x_358) x_359) ?v_467) x_367)) (and (and (and (and (and (and (and (and ?v_488 x_303) x_304) ?v_498) x_273) ?v_396) ?v_394) ?v_467) ?v_457))) ?v_499) ?v_490) ?v_500) ?v_485) ?v_493) ?v_494)) (and (and (and (and (and (and (and (= ?v_480 4) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_503) ?v_501) ?v_504) ?v_502) x_360) ?v_400) x_368) ?v_459) (and (and (and (and (and (and (and ?v_482 x_305) ?v_501) x_274) ?v_502) ?v_402) x_361) ?v_494)) (and (and (and (and (and (and ?v_486 ?v_503) x_306) x_360) x_361) ?v_469) x_369)) (and (and (and (and (and (and (and (and ?v_488 x_305) x_306) ?v_504) x_275) ?v_402) ?v_400) ?v_469) ?v_459))) ?v_499) ?v_490) ?v_500) ?v_485) ?v_491) ?v_492))) ?v_551) ?v_506) ?v_550) ?v_575) ?v_574) (and (and (and (and (and (and (and (and (and (= ?v_505 1) (or (or (or (and (and (and (and (= ?v_549 0) (not ?v_572)) (= (- x_321 x_322) 0)) ?v_506) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 1) ?v_563) ?v_552) ?v_564) ?v_553) (ite ?v_533 (= ?v_85 1) ?v_507)) (ite ?v_534 (= ?v_86 1) ?v_509)) (ite ?v_535 (= ?v_87 1) ?v_510)) (ite ?v_536 (= ?v_88 1) ?v_511)) (ite ?v_537 (= ?v_89 1) ?v_512)) (ite ?v_538 (= ?v_90 1) ?v_513)) (ite ?v_539 (= ?v_91 1) ?v_514)) (ite ?v_540 (= ?v_92 1) ?v_515)) (ite ?v_541 (= ?v_93 1) ?v_516)) (ite ?v_542 (= ?v_94 1) ?v_517)) (ite ?v_543 (= ?v_95 1) ?v_518)) (ite ?v_544 (= ?v_96 1) ?v_519)) x_343) ?v_452) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525) ?v_378) ?v_376) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 2) ?v_566) ?v_555) ?v_567) ?v_556) (ite ?v_533 (= ?v_85 2) ?v_507)) (ite ?v_534 (= ?v_86 2) ?v_509)) (ite ?v_535 (= ?v_87 2) ?v_510)) (ite ?v_536 (= ?v_88 2) ?v_511)) (ite ?v_537 (= ?v_89 2) ?v_512)) (ite ?v_538 (= ?v_90 2) ?v_513)) (ite ?v_539 (= ?v_91 2) ?v_514)) (ite ?v_540 (= ?v_92 2) ?v_515)) (ite ?v_541 (= ?v_93 2) ?v_516)) (ite ?v_542 (= ?v_94 2) ?v_517)) (ite ?v_543 (= ?v_95 2) ?v_518)) (ite ?v_544 (= ?v_96 2) ?v_519)) ?v_545) ?v_546) x_345) ?v_455) ?v_522) ?v_523) ?v_524) ?v_525) ?v_547) ?v_548) ?v_388) ?v_383) ?v_528) ?v_529) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 3) ?v_568) ?v_558) ?v_569) ?v_559) (ite ?v_533 (= ?v_85 3) ?v_507)) (ite ?v_534 (= ?v_86 3) ?v_509)) (ite ?v_535 (= ?v_87 3) ?v_510)) (ite ?v_536 (= ?v_88 3) ?v_511)) (ite ?v_537 (= ?v_89 3) ?v_512)) (ite ?v_538 (= ?v_90 3) ?v_513)) (ite ?v_539 (= ?v_91 3) ?v_514)) (ite ?v_540 (= ?v_92 3) ?v_515)) (ite ?v_541 (= ?v_93 3) ?v_516)) (ite ?v_542 (= ?v_94 3) ?v_517)) (ite ?v_543 (= ?v_95 3) ?v_518)) (ite ?v_544 (= ?v_96 3) ?v_519)) ?v_545) ?v_546) ?v_520) ?v_521) x_347) ?v_458) ?v_524) ?v_525) ?v_547) ?v_548) ?v_526) ?v_527) ?v_397) ?v_395) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 4) ?v_570) ?v_560) ?v_571) ?v_561) (ite ?v_533 (= ?v_85 4) ?v_507)) (ite ?v_534 (= ?v_86 4) ?v_509)) (ite ?v_535 (= ?v_87 4) ?v_510)) (ite ?v_536 (= ?v_88 4) ?v_511)) (ite ?v_537 (= ?v_89 4) ?v_512)) (ite ?v_538 (= ?v_90 4) ?v_513)) (ite ?v_539 (= ?v_91 4) ?v_514)) (ite ?v_540 (= ?v_92 4) ?v_515)) (ite ?v_541 (= ?v_93 4) ?v_516)) (ite ?v_542 (= ?v_94 4) ?v_517)) (ite ?v_543 (= ?v_95 4) ?v_518)) (ite ?v_544 (= ?v_96 4) ?v_519)) ?v_545) ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) x_349) ?v_460) ?v_547) ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) ?v_403) ?v_401))) (and (and (and (and (= ?v_549 1) ?v_550) ?v_506) ?v_551) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 1) x_307) ?v_552) x_288) ?v_553) (= ?v_557 1)) ?v_463) x_344) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525) x_323) ?v_376) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 2) x_309) ?v_555) x_290) ?v_556) (= ?v_557 2)) ?v_545) ?v_546) ?v_466) x_346) ?v_522) ?v_523) ?v_524) ?v_525) ?v_547) ?v_548) x_325) ?v_383) ?v_528) ?v_529) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 3) x_311) ?v_558) x_292) ?v_559) (= ?v_557 3)) ?v_545) ?v_546) ?v_520) ?v_521) ?v_468) x_348) ?v_524) ?v_525) ?v_547) ?v_548) ?v_526) ?v_527) x_327) ?v_395) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 4) x_313) ?v_560) x_294) ?v_561) (= ?v_557 4)) ?v_545) ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) ?v_470) x_350) ?v_547) ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) x_329) ?v_401)))) (and (and (and (and (= ?v_549 2) (= ?v_562 1)) ?v_550) ?v_551) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 1) ?v_563) x_308) ?v_564) x_289) ?v_463) ?v_452) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525) ?v_378) x_324) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 2) ?v_566) x_310) ?v_567) x_291) ?v_545) ?v_546) ?v_466) ?v_455) ?v_522) ?v_523) ?v_524) ?v_525) ?v_547) ?v_548) ?v_388) x_326) ?v_528) ?v_529) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 3) ?v_568) x_312) ?v_569) x_293) ?v_545) ?v_546) ?v_520) ?v_521) ?v_468) ?v_458) ?v_524) ?v_525) ?v_547) ?v_548) ?v_526) ?v_527) ?v_397) x_328) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 4) ?v_570) x_314) ?v_571) x_295) ?v_545) ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) ?v_470) ?v_460) ?v_547) ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) ?v_403) x_330)))) (and (and (and (and (and (and (and (= ?v_549 3) (= (- x_297 x_322) 0)) ?v_572) ?v_573) (= ?v_84 0)) ?v_574) ?v_550) ?v_575))) ?v_499) ?v_500) ?v_491) ?v_493) ?v_490) ?v_485) ?v_492) ?v_494))) (or (and (and (and (and (and (and (= ?v_606 0) (or (or (or (and (and (and (and (and (and (and (= ?v_581 1) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_579) ?v_577) ?v_580) ?v_578) x_299) ?v_476) x_307) ?v_552) (and (and (and (and (and (and (and ?v_583 x_244) ?v_577) x_213) ?v_578) ?v_478) x_300) ?v_591)) (and (and (and (and (and (and ?v_587 ?v_579) x_245) x_299) x_300) ?v_563) x_308)) (and (and (and (and (and (and (and (and ?v_589 x_244) x_245) ?v_580) x_214) ?v_478) ?v_476) ?v_563) ?v_552))) ?v_601) ?v_586) ?v_592) ?v_593) ?v_594) ?v_595) (and (and (and (and (and (and (and (= ?v_581 2) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_588) ?v_584) ?v_590) ?v_585) x_301) ?v_483) x_309) ?v_555) (and (and (and (and (and (and (and ?v_583 x_246) ?v_584) x_215) ?v_585) ?v_487) x_302) ?v_586)) (and (and (and (and (and (and ?v_587 ?v_588) x_247) x_301) x_302) ?v_566) x_310)) (and (and (and (and (and (and (and (and ?v_589 x_246) x_247) ?v_590) x_216) ?v_487) ?v_483) ?v_566) ?v_555))) ?v_600) ?v_591) ?v_592) ?v_593) ?v_594) ?v_595)) (and (and (and (and (and (and (and (= ?v_581 3) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_598) ?v_596) ?v_599) ?v_597) x_303) ?v_495) x_311) ?v_558) (and (and (and (and (and (and (and ?v_583 x_248) ?v_596) x_217) ?v_597) ?v_497) x_304) ?v_593)) (and (and (and (and (and (and ?v_587 ?v_598) x_249) x_303) x_304) ?v_568) x_312)) (and (and (and (and (and (and (and (and ?v_589 x_248) x_249) ?v_599) x_218) ?v_497) ?v_495) ?v_568) ?v_558))) ?v_600) ?v_591) ?v_601) ?v_586) ?v_594) ?v_595)) (and (and (and (and (and (and (and (= ?v_581 4) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_604) ?v_602) ?v_605) ?v_603) x_305) ?v_501) x_313) ?v_560) (and (and (and (and (and (and (and ?v_583 x_250) ?v_602) x_219) ?v_603) ?v_503) x_306) ?v_595)) (and (and (and (and (and (and ?v_587 ?v_604) x_251) x_305) x_306) ?v_570) x_314)) (and (and (and (and (and (and (and (and ?v_589 x_250) x_251) ?v_605) x_220) ?v_503) ?v_501) ?v_570) ?v_560))) ?v_600) ?v_591) ?v_601) ?v_586) ?v_592) ?v_593))) ?v_652) ?v_607) ?v_651) ?v_676) ?v_675) (and (and (and (and (and (and (and (and (and (= ?v_606 1) (or (or (or (and (and (and (and (= ?v_650 0) (not ?v_673)) (= (- x_266 x_267) 0)) ?v_607) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 1) ?v_664) ?v_653) ?v_665) ?v_654) (ite ?v_634 (= ?v_71 1) ?v_608)) (ite ?v_635 (= ?v_72 1) ?v_610)) (ite ?v_636 (= ?v_73 1) ?v_611)) (ite ?v_637 (= ?v_74 1) ?v_612)) (ite ?v_638 (= ?v_75 1) ?v_613)) (ite ?v_639 (= ?v_76 1) ?v_614)) (ite ?v_640 (= ?v_77 1) ?v_615)) (ite ?v_641 (= ?v_78 1) ?v_616)) (ite ?v_642 (= ?v_79 1) ?v_617)) (ite ?v_643 (= ?v_80 1) ?v_618)) (ite ?v_644 (= ?v_81 1) ?v_619)) (ite ?v_645 (= ?v_82 1) ?v_620)) x_288) ?v_553) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626) ?v_479) ?v_477) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 2) ?v_667) ?v_656) ?v_668) ?v_657) (ite ?v_634 (= ?v_71 2) ?v_608)) (ite ?v_635 (= ?v_72 2) ?v_610)) (ite ?v_636 (= ?v_73 2) ?v_611)) (ite ?v_637 (= ?v_74 2) ?v_612)) (ite ?v_638 (= ?v_75 2) ?v_613)) (ite ?v_639 (= ?v_76 2) ?v_614)) (ite ?v_640 (= ?v_77 2) ?v_615)) (ite ?v_641 (= ?v_78 2) ?v_616)) (ite ?v_642 (= ?v_79 2) ?v_617)) (ite ?v_643 (= ?v_80 2) ?v_618)) (ite ?v_644 (= ?v_81 2) ?v_619)) (ite ?v_645 (= ?v_82 2) ?v_620)) ?v_646) ?v_647) x_290) ?v_556) ?v_623) ?v_624) ?v_625) ?v_626) ?v_648) ?v_649) ?v_489) ?v_484) ?v_629) ?v_630) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 3) ?v_669) ?v_659) ?v_670) ?v_660) (ite ?v_634 (= ?v_71 3) ?v_608)) (ite ?v_635 (= ?v_72 3) ?v_610)) (ite ?v_636 (= ?v_73 3) ?v_611)) (ite ?v_637 (= ?v_74 3) ?v_612)) (ite ?v_638 (= ?v_75 3) ?v_613)) (ite ?v_639 (= ?v_76 3) ?v_614)) (ite ?v_640 (= ?v_77 3) ?v_615)) (ite ?v_641 (= ?v_78 3) ?v_616)) (ite ?v_642 (= ?v_79 3) ?v_617)) (ite ?v_643 (= ?v_80 3) ?v_618)) (ite ?v_644 (= ?v_81 3) ?v_619)) (ite ?v_645 (= ?v_82 3) ?v_620)) ?v_646) ?v_647) ?v_621) ?v_622) x_292) ?v_559) ?v_625) ?v_626) ?v_648) ?v_649) ?v_627) ?v_628) ?v_498) ?v_496) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 4) ?v_671) ?v_661) ?v_672) ?v_662) (ite ?v_634 (= ?v_71 4) ?v_608)) (ite ?v_635 (= ?v_72 4) ?v_610)) (ite ?v_636 (= ?v_73 4) ?v_611)) (ite ?v_637 (= ?v_74 4) ?v_612)) (ite ?v_638 (= ?v_75 4) ?v_613)) (ite ?v_639 (= ?v_76 4) ?v_614)) (ite ?v_640 (= ?v_77 4) ?v_615)) (ite ?v_641 (= ?v_78 4) ?v_616)) (ite ?v_642 (= ?v_79 4) ?v_617)) (ite ?v_643 (= ?v_80 4) ?v_618)) (ite ?v_644 (= ?v_81 4) ?v_619)) (ite ?v_645 (= ?v_82 4) ?v_620)) ?v_646) ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) x_294) ?v_561) ?v_648) ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) ?v_504) ?v_502))) (and (and (and (and (= ?v_650 1) ?v_651) ?v_607) ?v_652) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 1) x_252) ?v_653) x_233) ?v_654) (= ?v_658 1)) ?v_564) x_289) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626) x_268) ?v_477) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 2) x_254) ?v_656) x_235) ?v_657) (= ?v_658 2)) ?v_646) ?v_647) ?v_567) x_291) ?v_623) ?v_624) ?v_625) ?v_626) ?v_648) ?v_649) x_270) ?v_484) ?v_629) ?v_630) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 3) x_256) ?v_659) x_237) ?v_660) (= ?v_658 3)) ?v_646) ?v_647) ?v_621) ?v_622) ?v_569) x_293) ?v_625) ?v_626) ?v_648) ?v_649) ?v_627) ?v_628) x_272) ?v_496) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 4) x_258) ?v_661) x_239) ?v_662) (= ?v_658 4)) ?v_646) ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) ?v_571) x_295) ?v_648) ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) x_274) ?v_502)))) (and (and (and (and (= ?v_650 2) (= ?v_663 1)) ?v_651) ?v_652) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 1) ?v_664) x_253) ?v_665) x_234) ?v_564) ?v_553) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626) ?v_479) x_269) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 2) ?v_667) x_255) ?v_668) x_236) ?v_646) ?v_647) ?v_567) ?v_556) ?v_623) ?v_624) ?v_625) ?v_626) ?v_648) ?v_649) ?v_489) x_271) ?v_629) ?v_630) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 3) ?v_669) x_257) ?v_670) x_238) ?v_646) ?v_647) ?v_621) ?v_622) ?v_569) ?v_559) ?v_625) ?v_626) ?v_648) ?v_649) ?v_627) ?v_628) ?v_498) x_273) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 4) ?v_671) x_259) ?v_672) x_240) ?v_646) ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) ?v_571) ?v_561) ?v_648) ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) ?v_504) x_275)))) (and (and (and (and (and (and (and (= ?v_650 3) (= (- x_242 x_267) 0)) ?v_673) ?v_674) (= ?v_70 0)) ?v_675) ?v_651) ?v_676))) ?v_600) ?v_601) ?v_592) ?v_594) ?v_591) ?v_586) ?v_593) ?v_595))) (or (and (and (and (and (and (and (= ?v_707 0) (or (or (or (and (and (and (and (and (and (and (= ?v_682 1) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_680) ?v_678) ?v_681) ?v_679) x_244) ?v_577) x_252) ?v_653) (and (and (and (and (and (and (and ?v_684 x_189) ?v_678) x_158) ?v_679) ?v_579) x_245) ?v_692)) (and (and (and (and (and (and ?v_688 ?v_680) x_190) x_244) x_245) ?v_664) x_253)) (and (and (and (and (and (and (and (and ?v_690 x_189) x_190) ?v_681) x_159) ?v_579) ?v_577) ?v_664) ?v_653))) ?v_702) ?v_687) ?v_693) ?v_694) ?v_695) ?v_696) (and (and (and (and (and (and (and (= ?v_682 2) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_689) ?v_685) ?v_691) ?v_686) x_246) ?v_584) x_254) ?v_656) (and (and (and (and (and (and (and ?v_684 x_191) ?v_685) x_160) ?v_686) ?v_588) x_247) ?v_687)) (and (and (and (and (and (and ?v_688 ?v_689) x_192) x_246) x_247) ?v_667) x_255)) (and (and (and (and (and (and (and (and ?v_690 x_191) x_192) ?v_691) x_161) ?v_588) ?v_584) ?v_667) ?v_656))) ?v_701) ?v_692) ?v_693) ?v_694) ?v_695) ?v_696)) (and (and (and (and (and (and (and (= ?v_682 3) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_699) ?v_697) ?v_700) ?v_698) x_248) ?v_596) x_256) ?v_659) (and (and (and (and (and (and (and ?v_684 x_193) ?v_697) x_162) ?v_698) ?v_598) x_249) ?v_694)) (and (and (and (and (and (and ?v_688 ?v_699) x_194) x_248) x_249) ?v_669) x_257)) (and (and (and (and (and (and (and (and ?v_690 x_193) x_194) ?v_700) x_163) ?v_598) ?v_596) ?v_669) ?v_659))) ?v_701) ?v_692) ?v_702) ?v_687) ?v_695) ?v_696)) (and (and (and (and (and (and (and (= ?v_682 4) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_705) ?v_703) ?v_706) ?v_704) x_250) ?v_602) x_258) ?v_661) (and (and (and (and (and (and (and ?v_684 x_195) ?v_703) x_164) ?v_704) ?v_604) x_251) ?v_696)) (and (and (and (and (and (and ?v_688 ?v_705) x_196) x_250) x_251) ?v_671) x_259)) (and (and (and (and (and (and (and (and ?v_690 x_195) x_196) ?v_706) x_165) ?v_604) ?v_602) ?v_671) ?v_661))) ?v_701) ?v_692) ?v_702) ?v_687) ?v_693) ?v_694))) ?v_753) ?v_708) ?v_752) ?v_777) ?v_776) (and (and (and (and (and (and (and (and (and (= ?v_707 1) (or (or (or (and (and (and (and (= ?v_751 0) (not ?v_774)) (= (- x_211 x_212) 0)) ?v_708) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 1) ?v_765) ?v_754) ?v_766) ?v_755) (ite ?v_735 (= ?v_57 1) ?v_709)) (ite ?v_736 (= ?v_58 1) ?v_711)) (ite ?v_737 (= ?v_59 1) ?v_712)) (ite ?v_738 (= ?v_60 1) ?v_713)) (ite ?v_739 (= ?v_61 1) ?v_714)) (ite ?v_740 (= ?v_62 1) ?v_715)) (ite ?v_741 (= ?v_63 1) ?v_716)) (ite ?v_742 (= ?v_64 1) ?v_717)) (ite ?v_743 (= ?v_65 1) ?v_718)) (ite ?v_744 (= ?v_66 1) ?v_719)) (ite ?v_745 (= ?v_67 1) ?v_720)) (ite ?v_746 (= ?v_68 1) ?v_721)) x_233) ?v_654) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727) ?v_580) ?v_578) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 2) ?v_768) ?v_757) ?v_769) ?v_758) (ite ?v_735 (= ?v_57 2) ?v_709)) (ite ?v_736 (= ?v_58 2) ?v_711)) (ite ?v_737 (= ?v_59 2) ?v_712)) (ite ?v_738 (= ?v_60 2) ?v_713)) (ite ?v_739 (= ?v_61 2) ?v_714)) (ite ?v_740 (= ?v_62 2) ?v_715)) (ite ?v_741 (= ?v_63 2) ?v_716)) (ite ?v_742 (= ?v_64 2) ?v_717)) (ite ?v_743 (= ?v_65 2) ?v_718)) (ite ?v_744 (= ?v_66 2) ?v_719)) (ite ?v_745 (= ?v_67 2) ?v_720)) (ite ?v_746 (= ?v_68 2) ?v_721)) ?v_747) ?v_748) x_235) ?v_657) ?v_724) ?v_725) ?v_726) ?v_727) ?v_749) ?v_750) ?v_590) ?v_585) ?v_730) ?v_731) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 3) ?v_770) ?v_760) ?v_771) ?v_761) (ite ?v_735 (= ?v_57 3) ?v_709)) (ite ?v_736 (= ?v_58 3) ?v_711)) (ite ?v_737 (= ?v_59 3) ?v_712)) (ite ?v_738 (= ?v_60 3) ?v_713)) (ite ?v_739 (= ?v_61 3) ?v_714)) (ite ?v_740 (= ?v_62 3) ?v_715)) (ite ?v_741 (= ?v_63 3) ?v_716)) (ite ?v_742 (= ?v_64 3) ?v_717)) (ite ?v_743 (= ?v_65 3) ?v_718)) (ite ?v_744 (= ?v_66 3) ?v_719)) (ite ?v_745 (= ?v_67 3) ?v_720)) (ite ?v_746 (= ?v_68 3) ?v_721)) ?v_747) ?v_748) ?v_722) ?v_723) x_237) ?v_660) ?v_726) ?v_727) ?v_749) ?v_750) ?v_728) ?v_729) ?v_599) ?v_597) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 4) ?v_772) ?v_762) ?v_773) ?v_763) (ite ?v_735 (= ?v_57 4) ?v_709)) (ite ?v_736 (= ?v_58 4) ?v_711)) (ite ?v_737 (= ?v_59 4) ?v_712)) (ite ?v_738 (= ?v_60 4) ?v_713)) (ite ?v_739 (= ?v_61 4) ?v_714)) (ite ?v_740 (= ?v_62 4) ?v_715)) (ite ?v_741 (= ?v_63 4) ?v_716)) (ite ?v_742 (= ?v_64 4) ?v_717)) (ite ?v_743 (= ?v_65 4) ?v_718)) (ite ?v_744 (= ?v_66 4) ?v_719)) (ite ?v_745 (= ?v_67 4) ?v_720)) (ite ?v_746 (= ?v_68 4) ?v_721)) ?v_747) ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) x_239) ?v_662) ?v_749) ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) ?v_605) ?v_603))) (and (and (and (and (= ?v_751 1) ?v_752) ?v_708) ?v_753) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 1) x_197) ?v_754) x_178) ?v_755) (= ?v_759 1)) ?v_665) x_234) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727) x_213) ?v_578) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 2) x_199) ?v_757) x_180) ?v_758) (= ?v_759 2)) ?v_747) ?v_748) ?v_668) x_236) ?v_724) ?v_725) ?v_726) ?v_727) ?v_749) ?v_750) x_215) ?v_585) ?v_730) ?v_731) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 3) x_201) ?v_760) x_182) ?v_761) (= ?v_759 3)) ?v_747) ?v_748) ?v_722) ?v_723) ?v_670) x_238) ?v_726) ?v_727) ?v_749) ?v_750) ?v_728) ?v_729) x_217) ?v_597) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 4) x_203) ?v_762) x_184) ?v_763) (= ?v_759 4)) ?v_747) ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) ?v_672) x_240) ?v_749) ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) x_219) ?v_603)))) (and (and (and (and (= ?v_751 2) (= ?v_764 1)) ?v_752) ?v_753) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 1) ?v_765) x_198) ?v_766) x_179) ?v_665) ?v_654) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727) ?v_580) x_214) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 2) ?v_768) x_200) ?v_769) x_181) ?v_747) ?v_748) ?v_668) ?v_657) ?v_724) ?v_725) ?v_726) ?v_727) ?v_749) ?v_750) ?v_590) x_216) ?v_730) ?v_731) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 3) ?v_770) x_202) ?v_771) x_183) ?v_747) ?v_748) ?v_722) ?v_723) ?v_670) ?v_660) ?v_726) ?v_727) ?v_749) ?v_750) ?v_728) ?v_729) ?v_599) x_218) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 4) ?v_772) x_204) ?v_773) x_185) ?v_747) ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) ?v_672) ?v_662) ?v_749) ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) ?v_605) x_220)))) (and (and (and (and (and (and (and (= ?v_751 3) (= (- x_187 x_212) 0)) ?v_774) ?v_775) (= ?v_56 0)) ?v_776) ?v_752) ?v_777))) ?v_701) ?v_702) ?v_693) ?v_695) ?v_692) ?v_687) ?v_694) ?v_696))) (or (and (and (and (and (and (and (= ?v_808 0) (or (or (or (and (and (and (and (and (and (and (= ?v_783 1) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_781) ?v_779) ?v_782) ?v_780) x_189) ?v_678) x_197) ?v_754) (and (and (and (and (and (and (and ?v_785 x_134) ?v_779) x_103) ?v_780) ?v_680) x_190) ?v_793)) (and (and (and (and (and (and ?v_789 ?v_781) x_135) x_189) x_190) ?v_765) x_198)) (and (and (and (and (and (and (and (and ?v_791 x_134) x_135) ?v_782) x_104) ?v_680) ?v_678) ?v_765) ?v_754))) ?v_803) ?v_788) ?v_794) ?v_795) ?v_796) ?v_797) (and (and (and (and (and (and (and (= ?v_783 2) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_790) ?v_786) ?v_792) ?v_787) x_191) ?v_685) x_199) ?v_757) (and (and (and (and (and (and (and ?v_785 x_136) ?v_786) x_105) ?v_787) ?v_689) x_192) ?v_788)) (and (and (and (and (and (and ?v_789 ?v_790) x_137) x_191) x_192) ?v_768) x_200)) (and (and (and (and (and (and (and (and ?v_791 x_136) x_137) ?v_792) x_106) ?v_689) ?v_685) ?v_768) ?v_757))) ?v_802) ?v_793) ?v_794) ?v_795) ?v_796) ?v_797)) (and (and (and (and (and (and (and (= ?v_783 3) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_800) ?v_798) ?v_801) ?v_799) x_193) ?v_697) x_201) ?v_760) (and (and (and (and (and (and (and ?v_785 x_138) ?v_798) x_107) ?v_799) ?v_699) x_194) ?v_795)) (and (and (and (and (and (and ?v_789 ?v_800) x_139) x_193) x_194) ?v_770) x_202)) (and (and (and (and (and (and (and (and ?v_791 x_138) x_139) ?v_801) x_108) ?v_699) ?v_697) ?v_770) ?v_760))) ?v_802) ?v_793) ?v_803) ?v_788) ?v_796) ?v_797)) (and (and (and (and (and (and (and (= ?v_783 4) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_806) ?v_804) ?v_807) ?v_805) x_195) ?v_703) x_203) ?v_762) (and (and (and (and (and (and (and ?v_785 x_140) ?v_804) x_109) ?v_805) ?v_705) x_196) ?v_797)) (and (and (and (and (and (and ?v_789 ?v_806) x_141) x_195) x_196) ?v_772) x_204)) (and (and (and (and (and (and (and (and ?v_791 x_140) x_141) ?v_807) x_110) ?v_705) ?v_703) ?v_772) ?v_762))) ?v_802) ?v_793) ?v_803) ?v_788) ?v_794) ?v_795))) ?v_854) ?v_809) ?v_853) ?v_878) ?v_877) (and (and (and (and (and (and (and (and (and (= ?v_808 1) (or (or (or (and (and (and (and (= ?v_852 0) (not ?v_875)) (= (- x_156 x_157) 0)) ?v_809) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 1) ?v_866) ?v_855) ?v_867) ?v_856) (ite ?v_836 (= ?v_43 1) ?v_810)) (ite ?v_837 (= ?v_44 1) ?v_812)) (ite ?v_838 (= ?v_45 1) ?v_813)) (ite ?v_839 (= ?v_46 1) ?v_814)) (ite ?v_840 (= ?v_47 1) ?v_815)) (ite ?v_841 (= ?v_48 1) ?v_816)) (ite ?v_842 (= ?v_49 1) ?v_817)) (ite ?v_843 (= ?v_50 1) ?v_818)) (ite ?v_844 (= ?v_51 1) ?v_819)) (ite ?v_845 (= ?v_52 1) ?v_820)) (ite ?v_846 (= ?v_53 1) ?v_821)) (ite ?v_847 (= ?v_54 1) ?v_822)) x_178) ?v_755) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828) ?v_681) ?v_679) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 2) ?v_869) ?v_858) ?v_870) ?v_859) (ite ?v_836 (= ?v_43 2) ?v_810)) (ite ?v_837 (= ?v_44 2) ?v_812)) (ite ?v_838 (= ?v_45 2) ?v_813)) (ite ?v_839 (= ?v_46 2) ?v_814)) (ite ?v_840 (= ?v_47 2) ?v_815)) (ite ?v_841 (= ?v_48 2) ?v_816)) (ite ?v_842 (= ?v_49 2) ?v_817)) (ite ?v_843 (= ?v_50 2) ?v_818)) (ite ?v_844 (= ?v_51 2) ?v_819)) (ite ?v_845 (= ?v_52 2) ?v_820)) (ite ?v_846 (= ?v_53 2) ?v_821)) (ite ?v_847 (= ?v_54 2) ?v_822)) ?v_848) ?v_849) x_180) ?v_758) ?v_825) ?v_826) ?v_827) ?v_828) ?v_850) ?v_851) ?v_691) ?v_686) ?v_831) ?v_832) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 3) ?v_871) ?v_861) ?v_872) ?v_862) (ite ?v_836 (= ?v_43 3) ?v_810)) (ite ?v_837 (= ?v_44 3) ?v_812)) (ite ?v_838 (= ?v_45 3) ?v_813)) (ite ?v_839 (= ?v_46 3) ?v_814)) (ite ?v_840 (= ?v_47 3) ?v_815)) (ite ?v_841 (= ?v_48 3) ?v_816)) (ite ?v_842 (= ?v_49 3) ?v_817)) (ite ?v_843 (= ?v_50 3) ?v_818)) (ite ?v_844 (= ?v_51 3) ?v_819)) (ite ?v_845 (= ?v_52 3) ?v_820)) (ite ?v_846 (= ?v_53 3) ?v_821)) (ite ?v_847 (= ?v_54 3) ?v_822)) ?v_848) ?v_849) ?v_823) ?v_824) x_182) ?v_761) ?v_827) ?v_828) ?v_850) ?v_851) ?v_829) ?v_830) ?v_700) ?v_698) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 4) ?v_873) ?v_863) ?v_874) ?v_864) (ite ?v_836 (= ?v_43 4) ?v_810)) (ite ?v_837 (= ?v_44 4) ?v_812)) (ite ?v_838 (= ?v_45 4) ?v_813)) (ite ?v_839 (= ?v_46 4) ?v_814)) (ite ?v_840 (= ?v_47 4) ?v_815)) (ite ?v_841 (= ?v_48 4) ?v_816)) (ite ?v_842 (= ?v_49 4) ?v_817)) (ite ?v_843 (= ?v_50 4) ?v_818)) (ite ?v_844 (= ?v_51 4) ?v_819)) (ite ?v_845 (= ?v_52 4) ?v_820)) (ite ?v_846 (= ?v_53 4) ?v_821)) (ite ?v_847 (= ?v_54 4) ?v_822)) ?v_848) ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) x_184) ?v_763) ?v_850) ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) ?v_706) ?v_704))) (and (and (and (and (= ?v_852 1) ?v_853) ?v_809) ?v_854) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 1) x_142) ?v_855) x_123) ?v_856) (= ?v_860 1)) ?v_766) x_179) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828) x_158) ?v_679) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 2) x_144) ?v_858) x_125) ?v_859) (= ?v_860 2)) ?v_848) ?v_849) ?v_769) x_181) ?v_825) ?v_826) ?v_827) ?v_828) ?v_850) ?v_851) x_160) ?v_686) ?v_831) ?v_832) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 3) x_146) ?v_861) x_127) ?v_862) (= ?v_860 3)) ?v_848) ?v_849) ?v_823) ?v_824) ?v_771) x_183) ?v_827) ?v_828) ?v_850) ?v_851) ?v_829) ?v_830) x_162) ?v_698) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 4) x_148) ?v_863) x_129) ?v_864) (= ?v_860 4)) ?v_848) ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) ?v_773) x_185) ?v_850) ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) x_164) ?v_704)))) (and (and (and (and (= ?v_852 2) (= ?v_865 1)) ?v_853) ?v_854) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 1) ?v_866) x_143) ?v_867) x_124) ?v_766) ?v_755) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828) ?v_681) x_159) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 2) ?v_869) x_145) ?v_870) x_126) ?v_848) ?v_849) ?v_769) ?v_758) ?v_825) ?v_826) ?v_827) ?v_828) ?v_850) ?v_851) ?v_691) x_161) ?v_831) ?v_832) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 3) ?v_871) x_147) ?v_872) x_128) ?v_848) ?v_849) ?v_823) ?v_824) ?v_771) ?v_761) ?v_827) ?v_828) ?v_850) ?v_851) ?v_829) ?v_830) ?v_700) x_163) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 4) ?v_873) x_149) ?v_874) x_130) ?v_848) ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) ?v_773) ?v_763) ?v_850) ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) ?v_706) x_165)))) (and (and (and (and (and (and (and (= ?v_852 3) (= (- x_132 x_157) 0)) ?v_875) ?v_876) (= ?v_42 0)) ?v_877) ?v_853) ?v_878))) ?v_802) ?v_803) ?v_794) ?v_796) ?v_793) ?v_788) ?v_795) ?v_797))) (or (and (and (and (and (and (and (= ?v_909 0) (or (or (or (and (and (and (and (and (and (and (= ?v_884 1) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_882) ?v_880) ?v_883) ?v_881) x_134) ?v_779) x_142) ?v_855) (and (and (and (and (and (and (and ?v_886 x_79) ?v_880) x_48) ?v_881) ?v_781) x_135) ?v_894)) (and (and (and (and (and (and ?v_890 ?v_882) x_80) x_134) x_135) ?v_866) x_143)) (and (and (and (and (and (and (and (and ?v_892 x_79) x_80) ?v_883) x_49) ?v_781) ?v_779) ?v_866) ?v_855))) ?v_904) ?v_889) ?v_895) ?v_896) ?v_897) ?v_898) (and (and (and (and (and (and (and (= ?v_884 2) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_891) ?v_887) ?v_893) ?v_888) x_136) ?v_786) x_144) ?v_858) (and (and (and (and (and (and (and ?v_886 x_81) ?v_887) x_50) ?v_888) ?v_790) x_137) ?v_889)) (and (and (and (and (and (and ?v_890 ?v_891) x_82) x_136) x_137) ?v_869) x_145)) (and (and (and (and (and (and (and (and ?v_892 x_81) x_82) ?v_893) x_51) ?v_790) ?v_786) ?v_869) ?v_858))) ?v_903) ?v_894) ?v_895) ?v_896) ?v_897) ?v_898)) (and (and (and (and (and (and (and (= ?v_884 3) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_901) ?v_899) ?v_902) ?v_900) x_138) ?v_798) x_146) ?v_861) (and (and (and (and (and (and (and ?v_886 x_83) ?v_899) x_52) ?v_900) ?v_800) x_139) ?v_896)) (and (and (and (and (and (and ?v_890 ?v_901) x_84) x_138) x_139) ?v_871) x_147)) (and (and (and (and (and (and (and (and ?v_892 x_83) x_84) ?v_902) x_53) ?v_800) ?v_798) ?v_871) ?v_861))) ?v_903) ?v_894) ?v_904) ?v_889) ?v_897) ?v_898)) (and (and (and (and (and (and (and (= ?v_884 4) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_907) ?v_905) ?v_908) ?v_906) x_140) ?v_804) x_148) ?v_863) (and (and (and (and (and (and (and ?v_886 x_85) ?v_905) x_54) ?v_906) ?v_806) x_141) ?v_898)) (and (and (and (and (and (and ?v_890 ?v_907) x_86) x_140) x_141) ?v_873) x_149)) (and (and (and (and (and (and (and (and ?v_892 x_85) x_86) ?v_908) x_55) ?v_806) ?v_804) ?v_873) ?v_863))) ?v_903) ?v_894) ?v_904) ?v_889) ?v_895) ?v_896))) ?v_955) ?v_910) ?v_954) ?v_979) ?v_978) (and (and (and (and (and (and (and (and (and (= ?v_909 1) (or (or (or (and (and (and (and (= ?v_953 0) (not ?v_976)) (= (- x_101 x_102) 0)) ?v_910) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 1) ?v_967) ?v_956) ?v_968) ?v_957) (ite ?v_937 (= ?v_29 1) ?v_911)) (ite ?v_938 (= ?v_30 1) ?v_913)) (ite ?v_939 (= ?v_31 1) ?v_914)) (ite ?v_940 (= ?v_32 1) ?v_915)) (ite ?v_941 (= ?v_33 1) ?v_916)) (ite ?v_942 (= ?v_34 1) ?v_917)) (ite ?v_943 (= ?v_35 1) ?v_918)) (ite ?v_944 (= ?v_36 1) ?v_919)) (ite ?v_945 (= ?v_37 1) ?v_920)) (ite ?v_946 (= ?v_38 1) ?v_921)) (ite ?v_947 (= ?v_39 1) ?v_922)) (ite ?v_948 (= ?v_40 1) ?v_923)) x_123) ?v_856) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929) ?v_782) ?v_780) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 2) ?v_970) ?v_959) ?v_971) ?v_960) (ite ?v_937 (= ?v_29 2) ?v_911)) (ite ?v_938 (= ?v_30 2) ?v_913)) (ite ?v_939 (= ?v_31 2) ?v_914)) (ite ?v_940 (= ?v_32 2) ?v_915)) (ite ?v_941 (= ?v_33 2) ?v_916)) (ite ?v_942 (= ?v_34 2) ?v_917)) (ite ?v_943 (= ?v_35 2) ?v_918)) (ite ?v_944 (= ?v_36 2) ?v_919)) (ite ?v_945 (= ?v_37 2) ?v_920)) (ite ?v_946 (= ?v_38 2) ?v_921)) (ite ?v_947 (= ?v_39 2) ?v_922)) (ite ?v_948 (= ?v_40 2) ?v_923)) ?v_949) ?v_950) x_125) ?v_859) ?v_926) ?v_927) ?v_928) ?v_929) ?v_951) ?v_952) ?v_792) ?v_787) ?v_932) ?v_933) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 3) ?v_972) ?v_962) ?v_973) ?v_963) (ite ?v_937 (= ?v_29 3) ?v_911)) (ite ?v_938 (= ?v_30 3) ?v_913)) (ite ?v_939 (= ?v_31 3) ?v_914)) (ite ?v_940 (= ?v_32 3) ?v_915)) (ite ?v_941 (= ?v_33 3) ?v_916)) (ite ?v_942 (= ?v_34 3) ?v_917)) (ite ?v_943 (= ?v_35 3) ?v_918)) (ite ?v_944 (= ?v_36 3) ?v_919)) (ite ?v_945 (= ?v_37 3) ?v_920)) (ite ?v_946 (= ?v_38 3) ?v_921)) (ite ?v_947 (= ?v_39 3) ?v_922)) (ite ?v_948 (= ?v_40 3) ?v_923)) ?v_949) ?v_950) ?v_924) ?v_925) x_127) ?v_862) ?v_928) ?v_929) ?v_951) ?v_952) ?v_930) ?v_931) ?v_801) ?v_799) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 4) ?v_974) ?v_964) ?v_975) ?v_965) (ite ?v_937 (= ?v_29 4) ?v_911)) (ite ?v_938 (= ?v_30 4) ?v_913)) (ite ?v_939 (= ?v_31 4) ?v_914)) (ite ?v_940 (= ?v_32 4) ?v_915)) (ite ?v_941 (= ?v_33 4) ?v_916)) (ite ?v_942 (= ?v_34 4) ?v_917)) (ite ?v_943 (= ?v_35 4) ?v_918)) (ite ?v_944 (= ?v_36 4) ?v_919)) (ite ?v_945 (= ?v_37 4) ?v_920)) (ite ?v_946 (= ?v_38 4) ?v_921)) (ite ?v_947 (= ?v_39 4) ?v_922)) (ite ?v_948 (= ?v_40 4) ?v_923)) ?v_949) ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) x_129) ?v_864) ?v_951) ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) ?v_807) ?v_805))) (and (and (and (and (= ?v_953 1) ?v_954) ?v_910) ?v_955) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 1) x_87) ?v_956) x_68) ?v_957) (= ?v_961 1)) ?v_867) x_124) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929) x_103) ?v_780) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 2) x_89) ?v_959) x_70) ?v_960) (= ?v_961 2)) ?v_949) ?v_950) ?v_870) x_126) ?v_926) ?v_927) ?v_928) ?v_929) ?v_951) ?v_952) x_105) ?v_787) ?v_932) ?v_933) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 3) x_91) ?v_962) x_72) ?v_963) (= ?v_961 3)) ?v_949) ?v_950) ?v_924) ?v_925) ?v_872) x_128) ?v_928) ?v_929) ?v_951) ?v_952) ?v_930) ?v_931) x_107) ?v_799) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 4) x_93) ?v_964) x_74) ?v_965) (= ?v_961 4)) ?v_949) ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) ?v_874) x_130) ?v_951) ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) x_109) ?v_805)))) (and (and (and (and (= ?v_953 2) (= ?v_966 1)) ?v_954) ?v_955) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 1) ?v_967) x_88) ?v_968) x_69) ?v_867) ?v_856) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929) ?v_782) x_104) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 2) ?v_970) x_90) ?v_971) x_71) ?v_949) ?v_950) ?v_870) ?v_859) ?v_926) ?v_927) ?v_928) ?v_929) ?v_951) ?v_952) ?v_792) x_106) ?v_932) ?v_933) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 3) ?v_972) x_92) ?v_973) x_73) ?v_949) ?v_950) ?v_924) ?v_925) ?v_872) ?v_862) ?v_928) ?v_929) ?v_951) ?v_952) ?v_930) ?v_931) ?v_801) x_108) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 4) ?v_974) x_94) ?v_975) x_75) ?v_949) ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) ?v_874) ?v_864) ?v_951) ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) ?v_807) x_110)))) (and (and (and (and (and (and (and (= ?v_953 3) (= (- x_77 x_102) 0)) ?v_976) ?v_977) (= ?v_28 0)) ?v_978) ?v_954) ?v_979))) ?v_903) ?v_904) ?v_895) ?v_897) ?v_894) ?v_889) ?v_896) ?v_898))) (or (and (and (and (and (and (and (= ?v_1010 0) (or (or (or (and (and (and (and (and (and (and (= ?v_985 1) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_980) ?v_981) ?v_984) ?v_983) x_79) ?v_880) x_87) ?v_956) (and (and (and (and (and (and (and ?v_989 x_0) ?v_981) x_16) ?v_983) ?v_882) x_80) ?v_995)) (and (and (and (and (and (and ?v_992 ?v_980) x_1) x_79) x_80) ?v_967) x_88)) (and (and (and (and (and (and (and (and ?v_993 x_0) x_1) ?v_984) x_17) ?v_882) ?v_880) ?v_967) ?v_956))) ?v_1005) ?v_991) ?v_996) ?v_997) ?v_998) ?v_999) (and (and (and (and (and (and (and (= ?v_985 2) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_987) ?v_988) ?v_994) ?v_990) x_81) ?v_887) x_89) ?v_959) (and (and (and (and (and (and (and ?v_989 x_2) ?v_988) x_18) ?v_990) ?v_891) x_82) ?v_991)) (and (and (and (and (and (and ?v_992 ?v_987) x_3) x_81) x_82) ?v_970) x_90)) (and (and (and (and (and (and (and (and ?v_993 x_2) x_3) ?v_994) x_19) ?v_891) ?v_887) ?v_970) ?v_959))) ?v_1004) ?v_995) ?v_996) ?v_997) ?v_998) ?v_999)) (and (and (and (and (and (and (and (= ?v_985 3) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_1000) ?v_1001) ?v_1003) ?v_1002) x_83) ?v_899) x_91) ?v_962) (and (and (and (and (and (and (and ?v_989 x_4) ?v_1001) x_20) ?v_1002) ?v_901) x_84) ?v_997)) (and (and (and (and (and (and ?v_992 ?v_1000) x_5) x_83) x_84) ?v_972) x_92)) (and (and (and (and (and (and (and (and ?v_993 x_4) x_5) ?v_1003) x_21) ?v_901) ?v_899) ?v_972) ?v_962))) ?v_1004) ?v_995) ?v_1005) ?v_991) ?v_998) ?v_999)) (and (and (and (and (and (and (and (= ?v_985 4) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_1006) ?v_1007) ?v_1009) ?v_1008) x_85) ?v_905) x_93) ?v_964) (and (and (and (and (and (and (and ?v_989 x_6) ?v_1007) x_22) ?v_1008) ?v_907) x_86) ?v_999)) (and (and (and (and (and (and ?v_992 ?v_1006) x_7) x_85) x_86) ?v_974) x_94)) (and (and (and (and (and (and (and (and ?v_993 x_6) x_7) ?v_1009) x_23) ?v_907) ?v_905) ?v_974) ?v_964))) ?v_1004) ?v_995) ?v_1005) ?v_991) ?v_996) ?v_997))) ?v_1072) ?v_1011) ?v_1071) ?v_1080) ?v_1079) (and (and (and (and (and (and (and (and (and (= ?v_1010 1) (or (or (or (and (and (and (and (= ?v_1070 0) (not ?v_1077)) (= (- x_46 x_47) 0)) ?v_1011) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 1) ?v_1012) ?v_1013) ?v_1014) ?v_1015) (ite ?v_1046 (= ?v_15 1) ?v_1016)) (ite ?v_1047 (= ?v_16 1) ?v_1018)) (ite ?v_1048 (= ?v_17 1) ?v_1019)) (ite ?v_1049 (= ?v_18 1) ?v_1020)) (ite ?v_1050 (= ?v_19 1) ?v_1021)) (ite ?v_1051 (= ?v_20 1) ?v_1022)) (ite ?v_1052 (= ?v_21 1) ?v_1023)) (ite ?v_1053 (= ?v_22 1) ?v_1024)) (ite ?v_1054 (= ?v_23 1) ?v_1025)) (ite ?v_1055 (= ?v_24 1) ?v_1026)) (ite ?v_1056 (= ?v_25 1) ?v_1027)) (ite ?v_1057 (= ?v_26 1) ?v_1028)) x_68) ?v_957) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_883) ?v_881) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 2) ?v_1042) ?v_1043) ?v_1044) ?v_1045) (ite ?v_1046 (= ?v_15 2) ?v_1016)) (ite ?v_1047 (= ?v_16 2) ?v_1018)) (ite ?v_1048 (= ?v_17 2) ?v_1019)) (ite ?v_1049 (= ?v_18 2) ?v_1020)) (ite ?v_1050 (= ?v_19 2) ?v_1021)) (ite ?v_1051 (= ?v_20 2) ?v_1022)) (ite ?v_1052 (= ?v_21 2) ?v_1023)) (ite ?v_1053 (= ?v_22 2) ?v_1024)) (ite ?v_1054 (= ?v_23 2) ?v_1025)) (ite ?v_1055 (= ?v_24 2) ?v_1026)) (ite ?v_1056 (= ?v_25 2) ?v_1027)) (ite ?v_1057 (= ?v_26 2) ?v_1028)) ?v_1058) ?v_1059) x_70) ?v_960) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_893) ?v_888) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 3) ?v_1062) ?v_1063) ?v_1064) ?v_1065) (ite ?v_1046 (= ?v_15 3) ?v_1016)) (ite ?v_1047 (= ?v_16 3) ?v_1018)) (ite ?v_1048 (= ?v_17 3) ?v_1019)) (ite ?v_1049 (= ?v_18 3) ?v_1020)) (ite ?v_1050 (= ?v_19 3) ?v_1021)) (ite ?v_1051 (= ?v_20 3) ?v_1022)) (ite ?v_1052 (= ?v_21 3) ?v_1023)) (ite ?v_1053 (= ?v_22 3) ?v_1024)) (ite ?v_1054 (= ?v_23 3) ?v_1025)) (ite ?v_1055 (= ?v_24 3) ?v_1026)) (ite ?v_1056 (= ?v_25 3) ?v_1027)) (ite ?v_1057 (= ?v_26 3) ?v_1028)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) x_72) ?v_963) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_902) ?v_900) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 4) ?v_1066) ?v_1067) ?v_1068) ?v_1069) (ite ?v_1046 (= ?v_15 4) ?v_1016)) (ite ?v_1047 (= ?v_16 4) ?v_1018)) (ite ?v_1048 (= ?v_17 4) ?v_1019)) (ite ?v_1049 (= ?v_18 4) ?v_1020)) (ite ?v_1050 (= ?v_19 4) ?v_1021)) (ite ?v_1051 (= ?v_20 4) ?v_1022)) (ite ?v_1052 (= ?v_21 4) ?v_1023)) (ite ?v_1053 (= ?v_22 4) ?v_1024)) (ite ?v_1054 (= ?v_23 4) ?v_1025)) (ite ?v_1055 (= ?v_24 4) ?v_1026)) (ite ?v_1056 (= ?v_25 4) ?v_1027)) (ite ?v_1057 (= ?v_26 4) ?v_1028)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) x_74) ?v_965) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_908) ?v_906))) (and (and (and (and (= ?v_1070 1) ?v_1071) ?v_1011) ?v_1072) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 1) x_8) ?v_1013) x_24) ?v_1015) (= ?v_1074 1)) ?v_968) x_69) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034) x_48) ?v_881) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 2) x_10) ?v_1043) x_26) ?v_1045) (= ?v_1074 2)) ?v_1058) ?v_1059) ?v_971) x_71) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_1060) ?v_1061) x_50) ?v_888) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 3) x_12) ?v_1063) x_28) ?v_1065) (= ?v_1074 3)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_973) x_73) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_1035) ?v_1036) x_52) ?v_900) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 4) x_14) ?v_1067) x_30) ?v_1069) (= ?v_1074 4)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_975) x_75) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) x_54) ?v_906)))) (and (and (and (and (= ?v_1070 2) (= ?v_1075 1)) ?v_1071) ?v_1072) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 1) ?v_1012) x_9) ?v_1014) x_25) ?v_968) ?v_957) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_883) x_49) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 2) ?v_1042) x_11) ?v_1044) x_27) ?v_1058) ?v_1059) ?v_971) ?v_960) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_893) x_51) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 3) ?v_1062) x_13) ?v_1064) x_29) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_973) ?v_963) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_902) x_53) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 4) ?v_1066) x_15) ?v_1068) x_31) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_975) ?v_965) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_908) x_55)))) (and (and (and (and (and (and (and (= ?v_1070 3) (= (- x_44 x_47) 0)) ?v_1077) ?v_1078) (= ?v_14 0)) ?v_1079) ?v_1071) ?v_1080))) ?v_1004) ?v_1005) ?v_996) ?v_998) ?v_995) ?v_991) ?v_997) ?v_999))) (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_1082 (or (or ?v_1081 ?v_1083) ?v_1084)) (and ?v_1081 (or (or ?v_1082 ?v_1083) ?v_1084))) (and ?v_1083 (or ?v_1085 ?v_1084))) (and ?v_1084 (or ?v_1085 ?v_1083))) (and ?v_1087 (or (or ?v_1086 ?v_1088) ?v_1089))) (and ?v_1086 (or (or ?v_1087 ?v_1088) ?v_1089))) (and ?v_1088 (or ?v_1090 ?v_1089))) (and ?v_1089 (or ?v_1090 ?v_1088))) (and ?v_1092 (or (or ?v_1091 ?v_1093) ?v_1094))) (and ?v_1091 (or (or ?v_1092 ?v_1093) ?v_1094))) (and ?v_1093 (or ?v_1095 ?v_1094))) (and ?v_1094 (or ?v_1095 ?v_1093))) (and ?v_1097 (or (or ?v_1096 ?v_1098) ?v_1099))) (and ?v_1096 (or (or ?v_1097 ?v_1098) ?v_1099))) (and ?v_1098 (or ?v_1100 ?v_1099))) (and ?v_1099 (or ?v_1100 ?v_1098))) (and ?v_1102 (or (or ?v_1101 ?v_1103) ?v_1104))) (and ?v_1101 (or (or ?v_1102 ?v_1103) ?v_1104))) (and ?v_1103 (or ?v_1105 ?v_1104))) (and ?v_1104 (or ?v_1105 ?v_1103))) (and ?v_1107 (or (or ?v_1106 ?v_1108) ?v_1109))) (and ?v_1106 (or (or ?v_1107 ?v_1108) ?v_1109))) (and ?v_1108 (or ?v_1110 ?v_1109))) (and ?v_1109 (or ?v_1110 ?v_1108))) (and ?v_1112 (or (or ?v_1111 ?v_1113) ?v_1114))) (and ?v_1111 (or (or ?v_1112 ?v_1113) ?v_1114))) (and ?v_1113 (or ?v_1115 ?v_1114))) (and ?v_1114 (or ?v_1115 ?v_1113))) (and ?v_1117 (or (or ?v_1116 ?v_1118) ?v_1119))) (and ?v_1116 (or (or ?v_1117 ?v_1118) ?v_1119))) (and ?v_1118 (or ?v_1120 ?v_1119))) (and ?v_1119 (or ?v_1120 ?v_1118))) (and ?v_1122 (or (or ?v_1121 ?v_1123) ?v_1124))) (and ?v_1121 (or (or ?v_1122 ?v_1123) ?v_1124))) (and ?v_1123 (or ?v_1125 ?v_1124))) (and ?v_1124 (or ?v_1125 ?v_1123))) (and ?v_1127 (or (or ?v_1126 ?v_1128) ?v_1129))) (and ?v_1126 (or (or ?v_1127 ?v_1128) ?v_1129))) (and ?v_1128 (or ?v_1130 ?v_1129))) (and ?v_1129 (or ?v_1130 ?v_1128)))) (or ?v_1013 ?v_1012)) (or ?v_1043 ?v_1042)) (or ?v_1063 ?v_1062)) (or ?v_1067 ?v_1066)) (or ?v_1015 ?v_1014)) (or ?v_1045 ?v_1044)) (or ?v_1065 ?v_1064)) (or ?v_1069 ?v_1068)) (or ?v_957 ?v_968)) (or ?v_960 ?v_971)) (or ?v_963 ?v_973)) (or ?v_965 ?v_975)) (or ?v_956 ?v_967)) (or ?v_959 ?v_970)) (or ?v_962 ?v_972)) (or ?v_964 ?v_974)) (or ?v_856 ?v_867)) (or ?v_859 ?v_870)) (or ?v_862 ?v_872)) (or ?v_864 ?v_874)) (or ?v_855 ?v_866)) (or ?v_858 ?v_869)) (or ?v_861 ?v_871)) (or ?v_863 ?v_873)) (or ?v_755 ?v_766)) (or ?v_758 ?v_769)) (or ?v_761 ?v_771)) (or ?v_763 ?v_773)) (or ?v_754 ?v_765)) (or ?v_757 ?v_768)) (or ?v_760 ?v_770)) (or ?v_762 ?v_772)) (or ?v_654 ?v_665)) (or ?v_657 ?v_668)) (or ?v_660 ?v_670)) (or ?v_662 ?v_672)) (or ?v_653 ?v_664)) (or ?v_656 ?v_667)) (or ?v_659 ?v_669)) (or ?v_661 ?v_671)) (or ?v_553 ?v_564)) (or ?v_556 ?v_567)) (or ?v_559 ?v_569)) (or ?v_561 ?v_571)) (or ?v_552 ?v_563)) (or ?v_555 ?v_566)) (or ?v_558 ?v_568)) (or ?v_560 ?v_570)) (or ?v_452 ?v_463)) (or ?v_455 ?v_466)) (or ?v_458 ?v_468)) (or ?v_460 ?v_470)) (or ?v_451 ?v_462)) (or ?v_454 ?v_465)) (or ?v_457 ?v_467)) (or ?v_459 ?v_469)) (or ?v_351 ?v_362)) (or ?v_354 ?v_365)) (or ?v_357 ?v_367)) (or ?v_359 ?v_369)) (or ?v_350 ?v_361)) (or ?v_353 ?v_364)) (or ?v_356 ?v_366)) (or ?v_358 ?v_368)) (or ?v_235 ?v_250)) (or ?v_239 ?v_256)) (or ?v_243 ?v_261)) (or ?v_246 ?v_266)) (or ?v_234 ?v_249)) (or ?v_238 ?v_255)) (or ?v_242 ?v_260)) (or ?v_245 ?v_265)) (or ?v_252 ?v_251)) (or ?v_258 ?v_257)) (or ?v_263 ?v_262)) (or ?v_268 ?v_267)) (or ?v_149 ?v_148)) (or ?v_163 ?v_162)) (or ?v_176 ?v_175)) (or ?v_186 ?v_185))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress1/arith/qlock-4-10-9.base.cvc.smt2 b/test/regress/regress1/arith/qlock-4-10-9.base.cvc.smt2 new file mode 100644 index 000000000..d71fc1340 --- /dev/null +++ b/test/regress/regress1/arith/qlock-4-10-9.base.cvc.smt2 @@ -0,0 +1,557 @@ +(set-logic QF_IDL) +(set-info :source | +Queuing lock algorithm by Kazuhiro Ogata (ogata@jaist.ac.jp). +Translated into CVC format by Leonardo de Moura. + +This benchmark was automatically translated into SMT-LIB format from +CVC format using CVC Lite + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun cvclZero () Int) +(declare-fun x_0 () Bool) +(declare-fun x_1 () Bool) +(declare-fun x_2 () Bool) +(declare-fun x_3 () Bool) +(declare-fun x_4 () Bool) +(declare-fun x_5 () Bool) +(declare-fun x_6 () Bool) +(declare-fun x_7 () Bool) +(declare-fun x_8 () Bool) +(declare-fun x_9 () Bool) +(declare-fun x_10 () Bool) +(declare-fun x_11 () Bool) +(declare-fun x_12 () Bool) +(declare-fun x_13 () Bool) +(declare-fun x_14 () Bool) +(declare-fun x_15 () Bool) +(declare-fun x_16 () Bool) +(declare-fun x_17 () Bool) +(declare-fun x_18 () Bool) +(declare-fun x_19 () Bool) +(declare-fun x_20 () Bool) +(declare-fun x_21 () Bool) +(declare-fun x_22 () Bool) +(declare-fun x_23 () Bool) +(declare-fun x_24 () Bool) +(declare-fun x_25 () Bool) +(declare-fun x_26 () Bool) +(declare-fun x_27 () Bool) +(declare-fun x_28 () Bool) +(declare-fun x_29 () Bool) +(declare-fun x_30 () Bool) +(declare-fun x_31 () Bool) +(declare-fun x_32 () Int) +(declare-fun x_33 () Int) +(declare-fun x_34 () Int) +(declare-fun x_35 () Int) +(declare-fun x_36 () Int) +(declare-fun x_37 () Int) +(declare-fun x_38 () Int) +(declare-fun x_39 () Int) +(declare-fun x_40 () Int) +(declare-fun x_41 () Int) +(declare-fun x_42 () Int) +(declare-fun x_43 () Int) +(declare-fun x_44 () Int) +(declare-fun x_45 () Int) +(declare-fun x_46 () Int) +(declare-fun x_47 () Int) +(declare-fun x_48 () Bool) +(declare-fun x_49 () Bool) +(declare-fun x_50 () Bool) +(declare-fun x_51 () Bool) +(declare-fun x_52 () Bool) +(declare-fun x_53 () Bool) +(declare-fun x_54 () Bool) +(declare-fun x_55 () Bool) +(declare-fun x_56 () Int) +(declare-fun x_57 () Int) +(declare-fun x_58 () Int) +(declare-fun x_59 () Int) +(declare-fun x_60 () Int) +(declare-fun x_61 () Int) +(declare-fun x_62 () Int) +(declare-fun x_63 () Int) +(declare-fun x_64 () Int) +(declare-fun x_65 () Int) +(declare-fun x_66 () Int) +(declare-fun x_67 () Int) +(declare-fun x_68 () Bool) +(declare-fun x_69 () Bool) +(declare-fun x_70 () Bool) +(declare-fun x_71 () Bool) +(declare-fun x_72 () Bool) +(declare-fun x_73 () Bool) +(declare-fun x_74 () Bool) +(declare-fun x_75 () Bool) +(declare-fun x_76 () Int) +(declare-fun x_77 () Int) +(declare-fun x_78 () Int) +(declare-fun x_79 () Bool) +(declare-fun x_80 () Bool) +(declare-fun x_81 () Bool) +(declare-fun x_82 () Bool) +(declare-fun x_83 () Bool) +(declare-fun x_84 () Bool) +(declare-fun x_85 () Bool) +(declare-fun x_86 () Bool) +(declare-fun x_87 () Bool) +(declare-fun x_88 () Bool) +(declare-fun x_89 () Bool) +(declare-fun x_90 () Bool) +(declare-fun x_91 () Bool) +(declare-fun x_92 () Bool) +(declare-fun x_93 () Bool) +(declare-fun x_94 () Bool) +(declare-fun x_95 () Int) +(declare-fun x_96 () Int) +(declare-fun x_97 () Int) +(declare-fun x_98 () Int) +(declare-fun x_99 () Int) +(declare-fun x_100 () Int) +(declare-fun x_101 () Int) +(declare-fun x_102 () Int) +(declare-fun x_103 () Bool) +(declare-fun x_104 () Bool) +(declare-fun x_105 () Bool) +(declare-fun x_106 () Bool) +(declare-fun x_107 () Bool) +(declare-fun x_108 () Bool) +(declare-fun x_109 () Bool) +(declare-fun x_110 () Bool) +(declare-fun x_111 () Int) +(declare-fun x_112 () Int) +(declare-fun x_113 () Int) +(declare-fun x_114 () Int) +(declare-fun x_115 () Int) +(declare-fun x_116 () Int) +(declare-fun x_117 () Int) +(declare-fun x_118 () Int) +(declare-fun x_119 () Int) +(declare-fun x_120 () Int) +(declare-fun x_121 () Int) +(declare-fun x_122 () Int) +(declare-fun x_123 () Bool) +(declare-fun x_124 () Bool) +(declare-fun x_125 () Bool) +(declare-fun x_126 () Bool) +(declare-fun x_127 () Bool) +(declare-fun x_128 () Bool) +(declare-fun x_129 () Bool) +(declare-fun x_130 () Bool) +(declare-fun x_131 () Int) +(declare-fun x_132 () Int) +(declare-fun x_133 () Int) +(declare-fun x_134 () Bool) +(declare-fun x_135 () Bool) +(declare-fun x_136 () Bool) +(declare-fun x_137 () Bool) +(declare-fun x_138 () Bool) +(declare-fun x_139 () Bool) +(declare-fun x_140 () Bool) +(declare-fun x_141 () Bool) +(declare-fun x_142 () Bool) +(declare-fun x_143 () Bool) +(declare-fun x_144 () Bool) +(declare-fun x_145 () Bool) +(declare-fun x_146 () Bool) +(declare-fun x_147 () Bool) +(declare-fun x_148 () Bool) +(declare-fun x_149 () Bool) +(declare-fun x_150 () Int) +(declare-fun x_151 () Int) +(declare-fun x_152 () Int) +(declare-fun x_153 () Int) +(declare-fun x_154 () Int) +(declare-fun x_155 () Int) +(declare-fun x_156 () Int) +(declare-fun x_157 () Int) +(declare-fun x_158 () Bool) +(declare-fun x_159 () Bool) +(declare-fun x_160 () Bool) +(declare-fun x_161 () Bool) +(declare-fun x_162 () Bool) +(declare-fun x_163 () Bool) +(declare-fun x_164 () Bool) +(declare-fun x_165 () Bool) +(declare-fun x_166 () Int) +(declare-fun x_167 () Int) +(declare-fun x_168 () Int) +(declare-fun x_169 () Int) +(declare-fun x_170 () Int) +(declare-fun x_171 () Int) +(declare-fun x_172 () Int) +(declare-fun x_173 () Int) +(declare-fun x_174 () Int) +(declare-fun x_175 () Int) +(declare-fun x_176 () Int) +(declare-fun x_177 () Int) +(declare-fun x_178 () Bool) +(declare-fun x_179 () Bool) +(declare-fun x_180 () Bool) +(declare-fun x_181 () Bool) +(declare-fun x_182 () Bool) +(declare-fun x_183 () Bool) +(declare-fun x_184 () Bool) +(declare-fun x_185 () Bool) +(declare-fun x_186 () Int) +(declare-fun x_187 () Int) +(declare-fun x_188 () Int) +(declare-fun x_189 () Bool) +(declare-fun x_190 () Bool) +(declare-fun x_191 () Bool) +(declare-fun x_192 () Bool) +(declare-fun x_193 () Bool) +(declare-fun x_194 () Bool) +(declare-fun x_195 () Bool) +(declare-fun x_196 () Bool) +(declare-fun x_197 () Bool) +(declare-fun x_198 () Bool) +(declare-fun x_199 () Bool) +(declare-fun x_200 () Bool) +(declare-fun x_201 () Bool) +(declare-fun x_202 () Bool) +(declare-fun x_203 () Bool) +(declare-fun x_204 () Bool) +(declare-fun x_205 () Int) +(declare-fun x_206 () Int) +(declare-fun x_207 () Int) +(declare-fun x_208 () Int) +(declare-fun x_209 () Int) +(declare-fun x_210 () Int) +(declare-fun x_211 () Int) +(declare-fun x_212 () Int) +(declare-fun x_213 () Bool) +(declare-fun x_214 () Bool) +(declare-fun x_215 () Bool) +(declare-fun x_216 () Bool) +(declare-fun x_217 () Bool) +(declare-fun x_218 () Bool) +(declare-fun x_219 () Bool) +(declare-fun x_220 () Bool) +(declare-fun x_221 () Int) +(declare-fun x_222 () Int) +(declare-fun x_223 () Int) +(declare-fun x_224 () Int) +(declare-fun x_225 () Int) +(declare-fun x_226 () Int) +(declare-fun x_227 () Int) +(declare-fun x_228 () Int) +(declare-fun x_229 () Int) +(declare-fun x_230 () Int) +(declare-fun x_231 () Int) +(declare-fun x_232 () Int) +(declare-fun x_233 () Bool) +(declare-fun x_234 () Bool) +(declare-fun x_235 () Bool) +(declare-fun x_236 () Bool) +(declare-fun x_237 () Bool) +(declare-fun x_238 () Bool) +(declare-fun x_239 () Bool) +(declare-fun x_240 () Bool) +(declare-fun x_241 () Int) +(declare-fun x_242 () Int) +(declare-fun x_243 () Int) +(declare-fun x_244 () Bool) +(declare-fun x_245 () Bool) +(declare-fun x_246 () Bool) +(declare-fun x_247 () Bool) +(declare-fun x_248 () Bool) +(declare-fun x_249 () Bool) +(declare-fun x_250 () Bool) +(declare-fun x_251 () Bool) +(declare-fun x_252 () Bool) +(declare-fun x_253 () Bool) +(declare-fun x_254 () Bool) +(declare-fun x_255 () Bool) +(declare-fun x_256 () Bool) +(declare-fun x_257 () Bool) +(declare-fun x_258 () Bool) +(declare-fun x_259 () Bool) +(declare-fun x_260 () Int) +(declare-fun x_261 () Int) +(declare-fun x_262 () Int) +(declare-fun x_263 () Int) +(declare-fun x_264 () Int) +(declare-fun x_265 () Int) +(declare-fun x_266 () Int) +(declare-fun x_267 () Int) +(declare-fun x_268 () Bool) +(declare-fun x_269 () Bool) +(declare-fun x_270 () Bool) +(declare-fun x_271 () Bool) +(declare-fun x_272 () Bool) +(declare-fun x_273 () Bool) +(declare-fun x_274 () Bool) +(declare-fun x_275 () Bool) +(declare-fun x_276 () Int) +(declare-fun x_277 () Int) +(declare-fun x_278 () Int) +(declare-fun x_279 () Int) +(declare-fun x_280 () Int) +(declare-fun x_281 () Int) +(declare-fun x_282 () Int) +(declare-fun x_283 () Int) +(declare-fun x_284 () Int) +(declare-fun x_285 () Int) +(declare-fun x_286 () Int) +(declare-fun x_287 () Int) +(declare-fun x_288 () Bool) +(declare-fun x_289 () Bool) +(declare-fun x_290 () Bool) +(declare-fun x_291 () Bool) +(declare-fun x_292 () Bool) +(declare-fun x_293 () Bool) +(declare-fun x_294 () Bool) +(declare-fun x_295 () Bool) +(declare-fun x_296 () Int) +(declare-fun x_297 () Int) +(declare-fun x_298 () Int) +(declare-fun x_299 () Bool) +(declare-fun x_300 () Bool) +(declare-fun x_301 () Bool) +(declare-fun x_302 () Bool) +(declare-fun x_303 () Bool) +(declare-fun x_304 () Bool) +(declare-fun x_305 () Bool) +(declare-fun x_306 () Bool) +(declare-fun x_307 () Bool) +(declare-fun x_308 () Bool) +(declare-fun x_309 () Bool) +(declare-fun x_310 () Bool) +(declare-fun x_311 () Bool) +(declare-fun x_312 () Bool) +(declare-fun x_313 () Bool) +(declare-fun x_314 () Bool) +(declare-fun x_315 () Int) +(declare-fun x_316 () Int) +(declare-fun x_317 () Int) +(declare-fun x_318 () Int) +(declare-fun x_319 () Int) +(declare-fun x_320 () Int) +(declare-fun x_321 () Int) +(declare-fun x_322 () Int) +(declare-fun x_323 () Bool) +(declare-fun x_324 () Bool) +(declare-fun x_325 () Bool) +(declare-fun x_326 () Bool) +(declare-fun x_327 () Bool) +(declare-fun x_328 () Bool) +(declare-fun x_329 () Bool) +(declare-fun x_330 () Bool) +(declare-fun x_331 () Int) +(declare-fun x_332 () Int) +(declare-fun x_333 () Int) +(declare-fun x_334 () Int) +(declare-fun x_335 () Int) +(declare-fun x_336 () Int) +(declare-fun x_337 () Int) +(declare-fun x_338 () Int) +(declare-fun x_339 () Int) +(declare-fun x_340 () Int) +(declare-fun x_341 () Int) +(declare-fun x_342 () Int) +(declare-fun x_343 () Bool) +(declare-fun x_344 () Bool) +(declare-fun x_345 () Bool) +(declare-fun x_346 () Bool) +(declare-fun x_347 () Bool) +(declare-fun x_348 () Bool) +(declare-fun x_349 () Bool) +(declare-fun x_350 () Bool) +(declare-fun x_351 () Int) +(declare-fun x_352 () Int) +(declare-fun x_353 () Int) +(declare-fun x_354 () Bool) +(declare-fun x_355 () Bool) +(declare-fun x_356 () Bool) +(declare-fun x_357 () Bool) +(declare-fun x_358 () Bool) +(declare-fun x_359 () Bool) +(declare-fun x_360 () Bool) +(declare-fun x_361 () Bool) +(declare-fun x_362 () Bool) +(declare-fun x_363 () Bool) +(declare-fun x_364 () Bool) +(declare-fun x_365 () Bool) +(declare-fun x_366 () Bool) +(declare-fun x_367 () Bool) +(declare-fun x_368 () Bool) +(declare-fun x_369 () Bool) +(declare-fun x_370 () Int) +(declare-fun x_371 () Int) +(declare-fun x_372 () Int) +(declare-fun x_373 () Int) +(declare-fun x_374 () Int) +(declare-fun x_375 () Int) +(declare-fun x_376 () Int) +(declare-fun x_377 () Int) +(declare-fun x_378 () Bool) +(declare-fun x_379 () Bool) +(declare-fun x_380 () Bool) +(declare-fun x_381 () Bool) +(declare-fun x_382 () Bool) +(declare-fun x_383 () Bool) +(declare-fun x_384 () Bool) +(declare-fun x_385 () Bool) +(declare-fun x_386 () Int) +(declare-fun x_387 () Int) +(declare-fun x_388 () Int) +(declare-fun x_389 () Int) +(declare-fun x_390 () Int) +(declare-fun x_391 () Int) +(declare-fun x_392 () Int) +(declare-fun x_393 () Int) +(declare-fun x_394 () Int) +(declare-fun x_395 () Int) +(declare-fun x_396 () Int) +(declare-fun x_397 () Int) +(declare-fun x_398 () Bool) +(declare-fun x_399 () Bool) +(declare-fun x_400 () Bool) +(declare-fun x_401 () Bool) +(declare-fun x_402 () Bool) +(declare-fun x_403 () Bool) +(declare-fun x_404 () Bool) +(declare-fun x_405 () Bool) +(declare-fun x_406 () Int) +(declare-fun x_407 () Int) +(declare-fun x_408 () Int) +(declare-fun x_409 () Bool) +(declare-fun x_410 () Bool) +(declare-fun x_411 () Bool) +(declare-fun x_412 () Bool) +(declare-fun x_413 () Bool) +(declare-fun x_414 () Bool) +(declare-fun x_415 () Bool) +(declare-fun x_416 () Bool) +(declare-fun x_417 () Bool) +(declare-fun x_418 () Bool) +(declare-fun x_419 () Bool) +(declare-fun x_420 () Bool) +(declare-fun x_421 () Bool) +(declare-fun x_422 () Bool) +(declare-fun x_423 () Bool) +(declare-fun x_424 () Bool) +(declare-fun x_425 () Int) +(declare-fun x_426 () Int) +(declare-fun x_427 () Int) +(declare-fun x_428 () Int) +(declare-fun x_429 () Int) +(declare-fun x_430 () Int) +(declare-fun x_431 () Int) +(declare-fun x_432 () Int) +(declare-fun x_433 () Bool) +(declare-fun x_434 () Bool) +(declare-fun x_435 () Bool) +(declare-fun x_436 () Bool) +(declare-fun x_437 () Bool) +(declare-fun x_438 () Bool) +(declare-fun x_439 () Bool) +(declare-fun x_440 () Bool) +(declare-fun x_441 () Int) +(declare-fun x_442 () Int) +(declare-fun x_443 () Int) +(declare-fun x_444 () Int) +(declare-fun x_445 () Int) +(declare-fun x_446 () Int) +(declare-fun x_447 () Int) +(declare-fun x_448 () Int) +(declare-fun x_449 () Int) +(declare-fun x_450 () Int) +(declare-fun x_451 () Int) +(declare-fun x_452 () Int) +(declare-fun x_453 () Bool) +(declare-fun x_454 () Bool) +(declare-fun x_455 () Bool) +(declare-fun x_456 () Bool) +(declare-fun x_457 () Bool) +(declare-fun x_458 () Bool) +(declare-fun x_459 () Bool) +(declare-fun x_460 () Bool) +(declare-fun x_461 () Int) +(declare-fun x_462 () Int) +(declare-fun x_463 () Int) +(declare-fun x_464 () Bool) +(declare-fun x_465 () Bool) +(declare-fun x_466 () Bool) +(declare-fun x_467 () Bool) +(declare-fun x_468 () Bool) +(declare-fun x_469 () Bool) +(declare-fun x_470 () Bool) +(declare-fun x_471 () Bool) +(declare-fun x_472 () Bool) +(declare-fun x_473 () Bool) +(declare-fun x_474 () Bool) +(declare-fun x_475 () Bool) +(declare-fun x_476 () Bool) +(declare-fun x_477 () Bool) +(declare-fun x_478 () Bool) +(declare-fun x_479 () Bool) +(declare-fun x_480 () Int) +(declare-fun x_481 () Int) +(declare-fun x_482 () Int) +(declare-fun x_483 () Int) +(declare-fun x_484 () Int) +(declare-fun x_485 () Int) +(declare-fun x_486 () Int) +(declare-fun x_487 () Int) +(declare-fun x_488 () Bool) +(declare-fun x_489 () Bool) +(declare-fun x_490 () Bool) +(declare-fun x_491 () Bool) +(declare-fun x_492 () Bool) +(declare-fun x_493 () Bool) +(declare-fun x_494 () Bool) +(declare-fun x_495 () Bool) +(declare-fun x_496 () Int) +(declare-fun x_497 () Int) +(declare-fun x_498 () Int) +(declare-fun x_499 () Int) +(declare-fun x_500 () Int) +(declare-fun x_501 () Int) +(declare-fun x_502 () Int) +(declare-fun x_503 () Int) +(declare-fun x_504 () Int) +(declare-fun x_505 () Int) +(declare-fun x_506 () Int) +(declare-fun x_507 () Int) +(declare-fun x_508 () Bool) +(declare-fun x_509 () Bool) +(declare-fun x_510 () Bool) +(declare-fun x_511 () Bool) +(declare-fun x_512 () Bool) +(declare-fun x_513 () Bool) +(declare-fun x_514 () Bool) +(declare-fun x_515 () Bool) +(declare-fun x_516 () Int) +(declare-fun x_517 () Int) +(declare-fun x_518 () Int) +(declare-fun x_519 () Bool) +(declare-fun x_520 () Bool) +(declare-fun x_521 () Bool) +(declare-fun x_522 () Bool) +(declare-fun x_523 () Bool) +(declare-fun x_524 () Bool) +(declare-fun x_525 () Bool) +(declare-fun x_526 () Bool) +(declare-fun x_527 () Bool) +(declare-fun x_528 () Bool) +(declare-fun x_529 () Bool) +(declare-fun x_530 () Bool) +(declare-fun x_531 () Bool) +(declare-fun x_532 () Bool) +(declare-fun x_533 () Bool) +(declare-fun x_534 () Bool) +(declare-fun x_535 () Int) +(declare-fun x_536 () Int) +(declare-fun x_537 () Int) +(declare-fun x_538 () Int) +(declare-fun x_539 () Int) +(declare-fun x_540 () Int) +(assert (let ((?v_1060 (= x_48 x_16)) (?v_1061 (= x_49 x_17)) (?v_1035 (= x_50 x_18)) (?v_1036 (= x_51 x_19)) (?v_1037 (= x_52 x_20)) (?v_1038 (= x_53 x_21)) (?v_1039 (= x_54 x_22)) (?v_1040 (= x_55 x_23))) (let ((?v_1079 (and (and (and (and (and (and (and ?v_1060 ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (?v_1058 (= x_68 x_24)) (?v_1059 (= x_69 x_25)) (?v_1029 (= x_70 x_26)) (?v_1030 (= x_71 x_27)) (?v_1031 (= x_72 x_28)) (?v_1032 (= x_73 x_29)) (?v_1033 (= x_74 x_30)) (?v_1034 (= x_75 x_31))) (let ((?v_1080 (and (and (and (and (and (and (and ?v_1058 ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034)) (?v_1004 (and (= x_79 x_0) (= x_80 x_1))) (?v_1005 (and (= x_81 x_2) (= x_82 x_3))) (?v_996 (and (= x_83 x_4) (= x_84 x_5))) (?v_998 (and (= x_85 x_6) (= x_86 x_7))) (?v_995 (and (= x_87 x_8) (= x_88 x_9))) (?v_991 (and (= x_89 x_10) (= x_90 x_11))) (?v_997 (and (= x_91 x_12) (= x_92 x_13))) (?v_999 (and (= x_93 x_14) (= x_94 x_15))) (?v_951 (= x_103 x_48)) (?v_952 (= x_104 x_49)) (?v_930 (= x_105 x_50)) (?v_931 (= x_106 x_51)) (?v_932 (= x_107 x_52)) (?v_933 (= x_108 x_53)) (?v_934 (= x_109 x_54)) (?v_935 (= x_110 x_55))) (let ((?v_978 (and (and (and (and (and (and (and ?v_951 ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935)) (?v_949 (= x_123 x_68)) (?v_950 (= x_124 x_69)) (?v_924 (= x_125 x_70)) (?v_925 (= x_126 x_71)) (?v_926 (= x_127 x_72)) (?v_927 (= x_128 x_73)) (?v_928 (= x_129 x_74)) (?v_929 (= x_130 x_75))) (let ((?v_979 (and (and (and (and (and (and (and ?v_949 ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929)) (?v_903 (and (= x_134 x_79) (= x_135 x_80))) (?v_904 (and (= x_136 x_81) (= x_137 x_82))) (?v_895 (and (= x_138 x_83) (= x_139 x_84))) (?v_897 (and (= x_140 x_85) (= x_141 x_86))) (?v_894 (and (= x_142 x_87) (= x_143 x_88))) (?v_889 (and (= x_144 x_89) (= x_145 x_90))) (?v_896 (and (= x_146 x_91) (= x_147 x_92))) (?v_898 (and (= x_148 x_93) (= x_149 x_94))) (?v_850 (= x_158 x_103)) (?v_851 (= x_159 x_104)) (?v_829 (= x_160 x_105)) (?v_830 (= x_161 x_106)) (?v_831 (= x_162 x_107)) (?v_832 (= x_163 x_108)) (?v_833 (= x_164 x_109)) (?v_834 (= x_165 x_110))) (let ((?v_877 (and (and (and (and (and (and (and ?v_850 ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834)) (?v_848 (= x_178 x_123)) (?v_849 (= x_179 x_124)) (?v_823 (= x_180 x_125)) (?v_824 (= x_181 x_126)) (?v_825 (= x_182 x_127)) (?v_826 (= x_183 x_128)) (?v_827 (= x_184 x_129)) (?v_828 (= x_185 x_130))) (let ((?v_878 (and (and (and (and (and (and (and ?v_848 ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828)) (?v_802 (and (= x_189 x_134) (= x_190 x_135))) (?v_803 (and (= x_191 x_136) (= x_192 x_137))) (?v_794 (and (= x_193 x_138) (= x_194 x_139))) (?v_796 (and (= x_195 x_140) (= x_196 x_141))) (?v_793 (and (= x_197 x_142) (= x_198 x_143))) (?v_788 (and (= x_199 x_144) (= x_200 x_145))) (?v_795 (and (= x_201 x_146) (= x_202 x_147))) (?v_797 (and (= x_203 x_148) (= x_204 x_149))) (?v_749 (= x_213 x_158)) (?v_750 (= x_214 x_159)) (?v_728 (= x_215 x_160)) (?v_729 (= x_216 x_161)) (?v_730 (= x_217 x_162)) (?v_731 (= x_218 x_163)) (?v_732 (= x_219 x_164)) (?v_733 (= x_220 x_165))) (let ((?v_776 (and (and (and (and (and (and (and ?v_749 ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733)) (?v_747 (= x_233 x_178)) (?v_748 (= x_234 x_179)) (?v_722 (= x_235 x_180)) (?v_723 (= x_236 x_181)) (?v_724 (= x_237 x_182)) (?v_725 (= x_238 x_183)) (?v_726 (= x_239 x_184)) (?v_727 (= x_240 x_185))) (let ((?v_777 (and (and (and (and (and (and (and ?v_747 ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727)) (?v_701 (and (= x_244 x_189) (= x_245 x_190))) (?v_702 (and (= x_246 x_191) (= x_247 x_192))) (?v_693 (and (= x_248 x_193) (= x_249 x_194))) (?v_695 (and (= x_250 x_195) (= x_251 x_196))) (?v_692 (and (= x_252 x_197) (= x_253 x_198))) (?v_687 (and (= x_254 x_199) (= x_255 x_200))) (?v_694 (and (= x_256 x_201) (= x_257 x_202))) (?v_696 (and (= x_258 x_203) (= x_259 x_204))) (?v_648 (= x_268 x_213)) (?v_649 (= x_269 x_214)) (?v_627 (= x_270 x_215)) (?v_628 (= x_271 x_216)) (?v_629 (= x_272 x_217)) (?v_630 (= x_273 x_218)) (?v_631 (= x_274 x_219)) (?v_632 (= x_275 x_220))) (let ((?v_675 (and (and (and (and (and (and (and ?v_648 ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632)) (?v_646 (= x_288 x_233)) (?v_647 (= x_289 x_234)) (?v_621 (= x_290 x_235)) (?v_622 (= x_291 x_236)) (?v_623 (= x_292 x_237)) (?v_624 (= x_293 x_238)) (?v_625 (= x_294 x_239)) (?v_626 (= x_295 x_240))) (let ((?v_676 (and (and (and (and (and (and (and ?v_646 ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626)) (?v_600 (and (= x_299 x_244) (= x_300 x_245))) (?v_601 (and (= x_301 x_246) (= x_302 x_247))) (?v_592 (and (= x_303 x_248) (= x_304 x_249))) (?v_594 (and (= x_305 x_250) (= x_306 x_251))) (?v_591 (and (= x_307 x_252) (= x_308 x_253))) (?v_586 (and (= x_309 x_254) (= x_310 x_255))) (?v_593 (and (= x_311 x_256) (= x_312 x_257))) (?v_595 (and (= x_313 x_258) (= x_314 x_259))) (?v_547 (= x_323 x_268)) (?v_548 (= x_324 x_269)) (?v_526 (= x_325 x_270)) (?v_527 (= x_326 x_271)) (?v_528 (= x_327 x_272)) (?v_529 (= x_328 x_273)) (?v_530 (= x_329 x_274)) (?v_531 (= x_330 x_275))) (let ((?v_574 (and (and (and (and (and (and (and ?v_547 ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531)) (?v_545 (= x_343 x_288)) (?v_546 (= x_344 x_289)) (?v_520 (= x_345 x_290)) (?v_521 (= x_346 x_291)) (?v_522 (= x_347 x_292)) (?v_523 (= x_348 x_293)) (?v_524 (= x_349 x_294)) (?v_525 (= x_350 x_295))) (let ((?v_575 (and (and (and (and (and (and (and ?v_545 ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525)) (?v_499 (and (= x_354 x_299) (= x_355 x_300))) (?v_500 (and (= x_356 x_301) (= x_357 x_302))) (?v_491 (and (= x_358 x_303) (= x_359 x_304))) (?v_493 (and (= x_360 x_305) (= x_361 x_306))) (?v_490 (and (= x_362 x_307) (= x_363 x_308))) (?v_485 (and (= x_364 x_309) (= x_365 x_310))) (?v_492 (and (= x_366 x_311) (= x_367 x_312))) (?v_494 (and (= x_368 x_313) (= x_369 x_314))) (?v_446 (= x_378 x_323)) (?v_447 (= x_379 x_324)) (?v_425 (= x_380 x_325)) (?v_426 (= x_381 x_326)) (?v_427 (= x_382 x_327)) (?v_428 (= x_383 x_328)) (?v_429 (= x_384 x_329)) (?v_430 (= x_385 x_330))) (let ((?v_473 (and (and (and (and (and (and (and ?v_446 ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430)) (?v_444 (= x_398 x_343)) (?v_445 (= x_399 x_344)) (?v_419 (= x_400 x_345)) (?v_420 (= x_401 x_346)) (?v_421 (= x_402 x_347)) (?v_422 (= x_403 x_348)) (?v_423 (= x_404 x_349)) (?v_424 (= x_405 x_350))) (let ((?v_474 (and (and (and (and (and (and (and ?v_444 ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424)) (?v_398 (and (= x_409 x_354) (= x_410 x_355))) (?v_399 (and (= x_411 x_356) (= x_412 x_357))) (?v_390 (and (= x_413 x_358) (= x_414 x_359))) (?v_392 (and (= x_415 x_360) (= x_416 x_361))) (?v_389 (and (= x_417 x_362) (= x_418 x_363))) (?v_384 (and (= x_419 x_364) (= x_420 x_365))) (?v_391 (and (= x_421 x_366) (= x_422 x_367))) (?v_393 (and (= x_423 x_368) (= x_424 x_369))) (?v_345 (= x_433 x_378)) (?v_346 (= x_434 x_379)) (?v_324 (= x_435 x_380)) (?v_325 (= x_436 x_381)) (?v_326 (= x_437 x_382)) (?v_327 (= x_438 x_383)) (?v_328 (= x_439 x_384)) (?v_329 (= x_440 x_385))) (let ((?v_372 (and (and (and (and (and (and (and ?v_345 ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329)) (?v_343 (= x_453 x_398)) (?v_344 (= x_454 x_399)) (?v_318 (= x_455 x_400)) (?v_319 (= x_456 x_401)) (?v_320 (= x_457 x_402)) (?v_321 (= x_458 x_403)) (?v_322 (= x_459 x_404)) (?v_323 (= x_460 x_405))) (let ((?v_373 (and (and (and (and (and (and (and ?v_343 ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323)) (?v_297 (and (= x_464 x_409) (= x_465 x_410))) (?v_298 (and (= x_466 x_411) (= x_467 x_412))) (?v_289 (and (= x_468 x_413) (= x_469 x_414))) (?v_291 (and (= x_470 x_415) (= x_471 x_416))) (?v_288 (and (= x_472 x_417) (= x_473 x_418))) (?v_283 (and (= x_474 x_419) (= x_475 x_420))) (?v_290 (and (= x_476 x_421) (= x_477 x_422))) (?v_292 (and (= x_478 x_423) (= x_479 x_424))) (?v_229 (= x_488 x_433)) (?v_230 (= x_489 x_434)) (?v_208 (= x_490 x_435)) (?v_209 (= x_491 x_436)) (?v_210 (= x_492 x_437)) (?v_211 (= x_493 x_438)) (?v_212 (= x_494 x_439)) (?v_213 (= x_495 x_440))) (let ((?v_271 (and (and (and (and (and (and (and ?v_229 ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213)) (?v_227 (= x_508 x_453)) (?v_228 (= x_509 x_454)) (?v_202 (= x_510 x_455)) (?v_203 (= x_511 x_456)) (?v_204 (= x_512 x_457)) (?v_205 (= x_513 x_458)) (?v_206 (= x_514 x_459)) (?v_207 (= x_515 x_460))) (let ((?v_272 (and (and (and (and (and (and (and ?v_227 ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207)) (?v_177 (and (= x_519 x_464) (= x_520 x_465))) (?v_178 (and (= x_521 x_466) (= x_522 x_467))) (?v_165 (and (= x_523 x_468) (= x_524 x_469))) (?v_167 (and (= x_525 x_470) (= x_526 x_471))) (?v_164 (and (= x_527 x_472) (= x_528 x_473))) (?v_155 (and (= x_529 x_474) (= x_530 x_475))) (?v_166 (and (= x_531 x_476) (= x_532 x_477))) (?v_168 (and (= x_533 x_478) (= x_534 x_479))) (?v_980 (not x_0)) (?v_981 (not x_1)) (?v_987 (not x_2)) (?v_988 (not x_3)) (?v_1000 (not x_4)) (?v_1001 (not x_5)) (?v_1006 (not x_6)) (?v_1007 (not x_7)) (?v_1012 (not x_8)) (?v_1013 (not x_9)) (?v_1042 (not x_10)) (?v_1043 (not x_11)) (?v_1062 (not x_12)) (?v_1063 (not x_13)) (?v_1066 (not x_14)) (?v_1067 (not x_15)) (?v_1014 (not x_24)) (?v_1015 (not x_25)) (?v_1044 (not x_26)) (?v_1045 (not x_27)) (?v_1064 (not x_28)) (?v_1065 (not x_29)) (?v_1068 (not x_30)) (?v_1069 (not x_31)) (?v_144 (not x_464)) (?v_142 (not x_465)) (?v_145 (not x_433)) (?v_143 (not x_434)) (?v_147 (not x_520)) (?v_149 (not x_528)) (?v_146 (not x_519)) (?v_148 (not x_527)) (?v_157 (not x_466)) (?v_153 (not x_467)) (?v_159 (not x_435)) (?v_154 (not x_436)) (?v_161 (not x_522)) (?v_163 (not x_530)) (?v_160 (not x_521)) (?v_162 (not x_529)) (?v_171 (not x_468)) (?v_169 (not x_469)) (?v_172 (not x_437)) (?v_170 (not x_438)) (?v_174 (not x_524)) (?v_176 (not x_532)) (?v_173 (not x_523)) (?v_175 (not x_531)) (?v_181 (not x_470)) (?v_179 (not x_471)) (?v_182 (not x_439)) (?v_180 (not x_440)) (?v_184 (not x_526)) (?v_186 (not x_534)) (?v_183 (not x_525)) (?v_185 (not x_533)) (?v_249 (not x_472)) (?v_234 (not x_473)) (?v_250 (not x_453)) (?v_235 (not x_454)) (?v_252 (not x_509)) (?v_253 (not x_488)) (?v_236 (not x_489)) (?v_255 (not x_474)) (?v_238 (not x_475)) (?v_256 (not x_455)) (?v_239 (not x_456)) (?v_258 (not x_511)) (?v_259 (not x_490)) (?v_241 (not x_491)) (?v_260 (not x_476)) (?v_242 (not x_477)) (?v_261 (not x_457)) (?v_243 (not x_458)) (?v_263 (not x_513)) (?v_264 (not x_492)) (?v_244 (not x_493)) (?v_265 (not x_478)) (?v_245 (not x_479)) (?v_266 (not x_459)) (?v_246 (not x_460)) (?v_268 (not x_515)) (?v_269 (not x_494)) (?v_247 (not x_495)) (?v_251 (not x_508)) (?v_257 (not x_510)) (?v_262 (not x_512)) (?v_267 (not x_514)) (?v_276 (not x_409)) (?v_274 (not x_410)) (?v_277 (not x_378)) (?v_275 (not x_379)) (?v_285 (not x_411)) (?v_281 (not x_412)) (?v_287 (not x_380)) (?v_282 (not x_381)) (?v_295 (not x_413)) (?v_293 (not x_414)) (?v_296 (not x_382)) (?v_294 (not x_383)) (?v_301 (not x_415)) (?v_299 (not x_416)) (?v_302 (not x_384)) (?v_300 (not x_385)) (?v_361 (not x_417)) (?v_350 (not x_418)) (?v_362 (not x_398)) (?v_351 (not x_399)) (?v_364 (not x_419)) (?v_353 (not x_420)) (?v_365 (not x_400)) (?v_354 (not x_401)) (?v_366 (not x_421)) (?v_356 (not x_422)) (?v_367 (not x_402)) (?v_357 (not x_403)) (?v_368 (not x_423)) (?v_358 (not x_424)) (?v_369 (not x_404)) (?v_359 (not x_405)) (?v_377 (not x_354)) (?v_375 (not x_355)) (?v_378 (not x_323)) (?v_376 (not x_324)) (?v_386 (not x_356)) (?v_382 (not x_357)) (?v_388 (not x_325)) (?v_383 (not x_326)) (?v_396 (not x_358)) (?v_394 (not x_359)) (?v_397 (not x_327)) (?v_395 (not x_328)) (?v_402 (not x_360)) (?v_400 (not x_361)) (?v_403 (not x_329)) (?v_401 (not x_330)) (?v_462 (not x_362)) (?v_451 (not x_363)) (?v_463 (not x_343)) (?v_452 (not x_344)) (?v_465 (not x_364)) (?v_454 (not x_365)) (?v_466 (not x_345)) (?v_455 (not x_346)) (?v_467 (not x_366)) (?v_457 (not x_367)) (?v_468 (not x_347)) (?v_458 (not x_348)) (?v_469 (not x_368)) (?v_459 (not x_369)) (?v_470 (not x_349)) (?v_460 (not x_350)) (?v_478 (not x_299)) (?v_476 (not x_300)) (?v_479 (not x_268)) (?v_477 (not x_269)) (?v_487 (not x_301)) (?v_483 (not x_302)) (?v_489 (not x_270)) (?v_484 (not x_271)) (?v_497 (not x_303)) (?v_495 (not x_304)) (?v_498 (not x_272)) (?v_496 (not x_273)) (?v_503 (not x_305)) (?v_501 (not x_306)) (?v_504 (not x_274)) (?v_502 (not x_275)) (?v_563 (not x_307)) (?v_552 (not x_308)) (?v_564 (not x_288)) (?v_553 (not x_289)) (?v_566 (not x_309)) (?v_555 (not x_310)) (?v_567 (not x_290)) (?v_556 (not x_291)) (?v_568 (not x_311)) (?v_558 (not x_312)) (?v_569 (not x_292)) (?v_559 (not x_293)) (?v_570 (not x_313)) (?v_560 (not x_314)) (?v_571 (not x_294)) (?v_561 (not x_295)) (?v_579 (not x_244)) (?v_577 (not x_245)) (?v_580 (not x_213)) (?v_578 (not x_214)) (?v_588 (not x_246)) (?v_584 (not x_247)) (?v_590 (not x_215)) (?v_585 (not x_216)) (?v_598 (not x_248)) (?v_596 (not x_249)) (?v_599 (not x_217)) (?v_597 (not x_218)) (?v_604 (not x_250)) (?v_602 (not x_251)) (?v_605 (not x_219)) (?v_603 (not x_220)) (?v_664 (not x_252)) (?v_653 (not x_253)) (?v_665 (not x_233)) (?v_654 (not x_234)) (?v_667 (not x_254)) (?v_656 (not x_255)) (?v_668 (not x_235)) (?v_657 (not x_236)) (?v_669 (not x_256)) (?v_659 (not x_257)) (?v_670 (not x_237)) (?v_660 (not x_238)) (?v_671 (not x_258)) (?v_661 (not x_259)) (?v_672 (not x_239)) (?v_662 (not x_240)) (?v_680 (not x_189)) (?v_678 (not x_190)) (?v_681 (not x_158)) (?v_679 (not x_159)) (?v_689 (not x_191)) (?v_685 (not x_192)) (?v_691 (not x_160)) (?v_686 (not x_161)) (?v_699 (not x_193)) (?v_697 (not x_194)) (?v_700 (not x_162)) (?v_698 (not x_163)) (?v_705 (not x_195)) (?v_703 (not x_196)) (?v_706 (not x_164)) (?v_704 (not x_165)) (?v_765 (not x_197)) (?v_754 (not x_198)) (?v_766 (not x_178)) (?v_755 (not x_179)) (?v_768 (not x_199)) (?v_757 (not x_200)) (?v_769 (not x_180)) (?v_758 (not x_181)) (?v_770 (not x_201)) (?v_760 (not x_202)) (?v_771 (not x_182)) (?v_761 (not x_183)) (?v_772 (not x_203)) (?v_762 (not x_204)) (?v_773 (not x_184)) (?v_763 (not x_185)) (?v_781 (not x_134)) (?v_779 (not x_135)) (?v_782 (not x_103)) (?v_780 (not x_104)) (?v_790 (not x_136)) (?v_786 (not x_137)) (?v_792 (not x_105)) (?v_787 (not x_106)) (?v_800 (not x_138)) (?v_798 (not x_139)) (?v_801 (not x_107)) (?v_799 (not x_108)) (?v_806 (not x_140)) (?v_804 (not x_141)) (?v_807 (not x_109)) (?v_805 (not x_110)) (?v_866 (not x_142)) (?v_855 (not x_143)) (?v_867 (not x_123)) (?v_856 (not x_124)) (?v_869 (not x_144)) (?v_858 (not x_145)) (?v_870 (not x_125)) (?v_859 (not x_126)) (?v_871 (not x_146)) (?v_861 (not x_147)) (?v_872 (not x_127)) (?v_862 (not x_128)) (?v_873 (not x_148)) (?v_863 (not x_149)) (?v_874 (not x_129)) (?v_864 (not x_130)) (?v_882 (not x_79)) (?v_880 (not x_80)) (?v_883 (not x_48)) (?v_881 (not x_49)) (?v_891 (not x_81)) (?v_887 (not x_82)) (?v_893 (not x_50)) (?v_888 (not x_51)) (?v_901 (not x_83)) (?v_899 (not x_84)) (?v_902 (not x_52)) (?v_900 (not x_53)) (?v_907 (not x_85)) (?v_905 (not x_86)) (?v_908 (not x_54)) (?v_906 (not x_55)) (?v_967 (not x_87)) (?v_956 (not x_88)) (?v_968 (not x_68)) (?v_957 (not x_69)) (?v_970 (not x_89)) (?v_959 (not x_90)) (?v_971 (not x_70)) (?v_960 (not x_71)) (?v_972 (not x_91)) (?v_962 (not x_92)) (?v_973 (not x_72)) (?v_963 (not x_73)) (?v_974 (not x_93)) (?v_964 (not x_94)) (?v_975 (not x_74)) (?v_965 (not x_75)) (?v_984 (not x_16)) (?v_983 (not x_17)) (?v_994 (not x_18)) (?v_990 (not x_19)) (?v_1003 (not x_20)) (?v_1002 (not x_21)) (?v_1009 (not x_22)) (?v_1008 (not x_23))) (let ((?v_1082 (and ?v_146 x_520)) (?v_1081 (and ?v_160 x_522)) (?v_1083 (and ?v_173 x_524)) (?v_1084 (and ?v_183 x_526))) (let ((?v_1085 (or ?v_1082 ?v_1081)) (?v_1087 (and ?v_144 x_465)) (?v_1086 (and ?v_157 x_467)) (?v_1088 (and ?v_171 x_469)) (?v_1089 (and ?v_181 x_471))) (let ((?v_1090 (or ?v_1087 ?v_1086)) (?v_1092 (and ?v_276 x_410)) (?v_1091 (and ?v_285 x_412)) (?v_1093 (and ?v_295 x_414)) (?v_1094 (and ?v_301 x_416))) (let ((?v_1095 (or ?v_1092 ?v_1091)) (?v_1097 (and ?v_377 x_355)) (?v_1096 (and ?v_386 x_357)) (?v_1098 (and ?v_396 x_359)) (?v_1099 (and ?v_402 x_361))) (let ((?v_1100 (or ?v_1097 ?v_1096)) (?v_1102 (and ?v_478 x_300)) (?v_1101 (and ?v_487 x_302)) (?v_1103 (and ?v_497 x_304)) (?v_1104 (and ?v_503 x_306))) (let ((?v_1105 (or ?v_1102 ?v_1101)) (?v_1107 (and ?v_579 x_245)) (?v_1106 (and ?v_588 x_247)) (?v_1108 (and ?v_598 x_249)) (?v_1109 (and ?v_604 x_251))) (let ((?v_1110 (or ?v_1107 ?v_1106)) (?v_1112 (and ?v_680 x_190)) (?v_1111 (and ?v_689 x_192)) (?v_1113 (and ?v_699 x_194)) (?v_1114 (and ?v_705 x_196))) (let ((?v_1115 (or ?v_1112 ?v_1111)) (?v_1117 (and ?v_781 x_135)) (?v_1116 (and ?v_790 x_137)) (?v_1118 (and ?v_800 x_139)) (?v_1119 (and ?v_806 x_141))) (let ((?v_1120 (or ?v_1117 ?v_1116)) (?v_1122 (and ?v_882 x_80)) (?v_1121 (and ?v_891 x_82)) (?v_1123 (and ?v_901 x_84)) (?v_1124 (and ?v_907 x_86))) (let ((?v_1125 (or ?v_1122 ?v_1121)) (?v_1127 (and ?v_980 x_1)) (?v_1126 (and ?v_987 x_3)) (?v_1128 (and ?v_1000 x_5)) (?v_1129 (and ?v_1006 x_7))) (let ((?v_1130 (or ?v_1127 ?v_1126)) (?v_12 (- x_44 cvclZero))) (let ((?v_140 (= ?v_12 1)) (?v_27 (- x_77 cvclZero))) (let ((?v_1078 (= ?v_27 1)) (?v_41 (- x_132 cvclZero))) (let ((?v_977 (= ?v_41 1)) (?v_55 (- x_187 cvclZero))) (let ((?v_876 (= ?v_55 1)) (?v_69 (- x_242 cvclZero))) (let ((?v_775 (= ?v_69 1)) (?v_83 (- x_297 cvclZero))) (let ((?v_674 (= ?v_83 1)) (?v_97 (- x_352 cvclZero))) (let ((?v_573 (= ?v_97 1)) (?v_111 (- x_407 cvclZero))) (let ((?v_472 (= ?v_111 1)) (?v_125 (- x_462 cvclZero))) (let ((?v_371 (= ?v_125 1)) (?v_141 (- x_516 cvclZero))) (let ((?v_151 (= ?v_141 0)) (?v_152 (= ?v_141 1)) (?v_156 (= ?v_141 2)) (?v_158 (= ?v_141 3)) (?v_233 (= (- x_486 x_431) 0)) (?v_248 (- x_517 x_462))) (let ((?v_188 (= ?v_248 0)) (?v_189 (= (- x_496 x_441) 0)) (?v_191 (= (- x_497 x_442) 0)) (?v_192 (= (- x_498 x_443) 0)) (?v_193 (= (- x_499 x_444) 0)) (?v_194 (= (- x_500 x_445) 0)) (?v_195 (= (- x_501 x_446) 0)) (?v_196 (= (- x_502 x_447) 0)) (?v_197 (= (- x_503 x_448) 0)) (?v_198 (= (- x_504 x_449) 0)) (?v_199 (= (- x_505 x_450) 0)) (?v_200 (= (- x_506 x_451) 0)) (?v_201 (= (- x_507 x_452) 0))) (let ((?v_232 (and (and (and (and (and (and (and (and (and (and (and ?v_189 ?v_191) ?v_192) ?v_193) ?v_194) ?v_195) ?v_196) ?v_197) ?v_198) ?v_199) ?v_200) ?v_201)) (?v_112 (- x_431 cvclZero))) (let ((?v_270 (= ?v_112 10)) (?v_190 (- x_487 cvclZero))) (let ((?v_215 (= ?v_190 0)) (?v_216 (= ?v_190 1)) (?v_217 (= ?v_190 2)) (?v_218 (= ?v_190 3)) (?v_219 (= ?v_190 4)) (?v_220 (= ?v_190 5)) (?v_221 (= ?v_190 6)) (?v_222 (= ?v_190 7)) (?v_223 (= ?v_190 8)) (?v_224 (= ?v_190 9)) (?v_225 (= ?v_190 10)) (?v_226 (= ?v_190 11)) (?v_273 (- x_461 cvclZero))) (let ((?v_279 (= ?v_273 0)) (?v_280 (= ?v_273 1)) (?v_284 (= ?v_273 2)) (?v_286 (= ?v_273 3)) (?v_349 (= (- x_431 x_376) 0)) (?v_360 (- x_462 x_407))) (let ((?v_304 (= ?v_360 0)) (?v_305 (= (- x_441 x_386) 0)) (?v_307 (= (- x_442 x_387) 0)) (?v_308 (= (- x_443 x_388) 0)) (?v_309 (= (- x_444 x_389) 0)) (?v_310 (= (- x_445 x_390) 0)) (?v_311 (= (- x_446 x_391) 0)) (?v_312 (= (- x_447 x_392) 0)) (?v_313 (= (- x_448 x_393) 0)) (?v_314 (= (- x_449 x_394) 0)) (?v_315 (= (- x_450 x_395) 0)) (?v_316 (= (- x_451 x_396) 0)) (?v_317 (= (- x_452 x_397) 0))) (let ((?v_348 (and (and (and (and (and (and (and (and (and (and (and ?v_305 ?v_307) ?v_308) ?v_309) ?v_310) ?v_311) ?v_312) ?v_313) ?v_314) ?v_315) ?v_316) ?v_317)) (?v_98 (- x_376 cvclZero))) (let ((?v_370 (= ?v_98 10)) (?v_306 (- x_432 cvclZero))) (let ((?v_331 (= ?v_306 0)) (?v_332 (= ?v_306 1)) (?v_333 (= ?v_306 2)) (?v_334 (= ?v_306 3)) (?v_335 (= ?v_306 4)) (?v_336 (= ?v_306 5)) (?v_337 (= ?v_306 6)) (?v_338 (= ?v_306 7)) (?v_339 (= ?v_306 8)) (?v_340 (= ?v_306 9)) (?v_341 (= ?v_306 10)) (?v_342 (= ?v_306 11)) (?v_374 (- x_406 cvclZero))) (let ((?v_380 (= ?v_374 0)) (?v_381 (= ?v_374 1)) (?v_385 (= ?v_374 2)) (?v_387 (= ?v_374 3)) (?v_450 (= (- x_376 x_321) 0)) (?v_461 (- x_407 x_352))) (let ((?v_405 (= ?v_461 0)) (?v_406 (= (- x_386 x_331) 0)) (?v_408 (= (- x_387 x_332) 0)) (?v_409 (= (- x_388 x_333) 0)) (?v_410 (= (- x_389 x_334) 0)) (?v_411 (= (- x_390 x_335) 0)) (?v_412 (= (- x_391 x_336) 0)) (?v_413 (= (- x_392 x_337) 0)) (?v_414 (= (- x_393 x_338) 0)) (?v_415 (= (- x_394 x_339) 0)) (?v_416 (= (- x_395 x_340) 0)) (?v_417 (= (- x_396 x_341) 0)) (?v_418 (= (- x_397 x_342) 0))) (let ((?v_449 (and (and (and (and (and (and (and (and (and (and (and ?v_406 ?v_408) ?v_409) ?v_410) ?v_411) ?v_412) ?v_413) ?v_414) ?v_415) ?v_416) ?v_417) ?v_418)) (?v_84 (- x_321 cvclZero))) (let ((?v_471 (= ?v_84 10)) (?v_407 (- x_377 cvclZero))) (let ((?v_432 (= ?v_407 0)) (?v_433 (= ?v_407 1)) (?v_434 (= ?v_407 2)) (?v_435 (= ?v_407 3)) (?v_436 (= ?v_407 4)) (?v_437 (= ?v_407 5)) (?v_438 (= ?v_407 6)) (?v_439 (= ?v_407 7)) (?v_440 (= ?v_407 8)) (?v_441 (= ?v_407 9)) (?v_442 (= ?v_407 10)) (?v_443 (= ?v_407 11)) (?v_475 (- x_351 cvclZero))) (let ((?v_481 (= ?v_475 0)) (?v_482 (= ?v_475 1)) (?v_486 (= ?v_475 2)) (?v_488 (= ?v_475 3)) (?v_551 (= (- x_321 x_266) 0)) (?v_562 (- x_352 x_297))) (let ((?v_506 (= ?v_562 0)) (?v_507 (= (- x_331 x_276) 0)) (?v_509 (= (- x_332 x_277) 0)) (?v_510 (= (- x_333 x_278) 0)) (?v_511 (= (- x_334 x_279) 0)) (?v_512 (= (- x_335 x_280) 0)) (?v_513 (= (- x_336 x_281) 0)) (?v_514 (= (- x_337 x_282) 0)) (?v_515 (= (- x_338 x_283) 0)) (?v_516 (= (- x_339 x_284) 0)) (?v_517 (= (- x_340 x_285) 0)) (?v_518 (= (- x_341 x_286) 0)) (?v_519 (= (- x_342 x_287) 0))) (let ((?v_550 (and (and (and (and (and (and (and (and (and (and (and ?v_507 ?v_509) ?v_510) ?v_511) ?v_512) ?v_513) ?v_514) ?v_515) ?v_516) ?v_517) ?v_518) ?v_519)) (?v_70 (- x_266 cvclZero))) (let ((?v_572 (= ?v_70 10)) (?v_508 (- x_322 cvclZero))) (let ((?v_533 (= ?v_508 0)) (?v_534 (= ?v_508 1)) (?v_535 (= ?v_508 2)) (?v_536 (= ?v_508 3)) (?v_537 (= ?v_508 4)) (?v_538 (= ?v_508 5)) (?v_539 (= ?v_508 6)) (?v_540 (= ?v_508 7)) (?v_541 (= ?v_508 8)) (?v_542 (= ?v_508 9)) (?v_543 (= ?v_508 10)) (?v_544 (= ?v_508 11)) (?v_576 (- x_296 cvclZero))) (let ((?v_582 (= ?v_576 0)) (?v_583 (= ?v_576 1)) (?v_587 (= ?v_576 2)) (?v_589 (= ?v_576 3)) (?v_652 (= (- x_266 x_211) 0)) (?v_663 (- x_297 x_242))) (let ((?v_607 (= ?v_663 0)) (?v_608 (= (- x_276 x_221) 0)) (?v_610 (= (- x_277 x_222) 0)) (?v_611 (= (- x_278 x_223) 0)) (?v_612 (= (- x_279 x_224) 0)) (?v_613 (= (- x_280 x_225) 0)) (?v_614 (= (- x_281 x_226) 0)) (?v_615 (= (- x_282 x_227) 0)) (?v_616 (= (- x_283 x_228) 0)) (?v_617 (= (- x_284 x_229) 0)) (?v_618 (= (- x_285 x_230) 0)) (?v_619 (= (- x_286 x_231) 0)) (?v_620 (= (- x_287 x_232) 0))) (let ((?v_651 (and (and (and (and (and (and (and (and (and (and (and ?v_608 ?v_610) ?v_611) ?v_612) ?v_613) ?v_614) ?v_615) ?v_616) ?v_617) ?v_618) ?v_619) ?v_620)) (?v_56 (- x_211 cvclZero))) (let ((?v_673 (= ?v_56 10)) (?v_609 (- x_267 cvclZero))) (let ((?v_634 (= ?v_609 0)) (?v_635 (= ?v_609 1)) (?v_636 (= ?v_609 2)) (?v_637 (= ?v_609 3)) (?v_638 (= ?v_609 4)) (?v_639 (= ?v_609 5)) (?v_640 (= ?v_609 6)) (?v_641 (= ?v_609 7)) (?v_642 (= ?v_609 8)) (?v_643 (= ?v_609 9)) (?v_644 (= ?v_609 10)) (?v_645 (= ?v_609 11)) (?v_677 (- x_241 cvclZero))) (let ((?v_683 (= ?v_677 0)) (?v_684 (= ?v_677 1)) (?v_688 (= ?v_677 2)) (?v_690 (= ?v_677 3)) (?v_753 (= (- x_211 x_156) 0)) (?v_764 (- x_242 x_187))) (let ((?v_708 (= ?v_764 0)) (?v_709 (= (- x_221 x_166) 0)) (?v_711 (= (- x_222 x_167) 0)) (?v_712 (= (- x_223 x_168) 0)) (?v_713 (= (- x_224 x_169) 0)) (?v_714 (= (- x_225 x_170) 0)) (?v_715 (= (- x_226 x_171) 0)) (?v_716 (= (- x_227 x_172) 0)) (?v_717 (= (- x_228 x_173) 0)) (?v_718 (= (- x_229 x_174) 0)) (?v_719 (= (- x_230 x_175) 0)) (?v_720 (= (- x_231 x_176) 0)) (?v_721 (= (- x_232 x_177) 0))) (let ((?v_752 (and (and (and (and (and (and (and (and (and (and (and ?v_709 ?v_711) ?v_712) ?v_713) ?v_714) ?v_715) ?v_716) ?v_717) ?v_718) ?v_719) ?v_720) ?v_721)) (?v_42 (- x_156 cvclZero))) (let ((?v_774 (= ?v_42 10)) (?v_710 (- x_212 cvclZero))) (let ((?v_735 (= ?v_710 0)) (?v_736 (= ?v_710 1)) (?v_737 (= ?v_710 2)) (?v_738 (= ?v_710 3)) (?v_739 (= ?v_710 4)) (?v_740 (= ?v_710 5)) (?v_741 (= ?v_710 6)) (?v_742 (= ?v_710 7)) (?v_743 (= ?v_710 8)) (?v_744 (= ?v_710 9)) (?v_745 (= ?v_710 10)) (?v_746 (= ?v_710 11)) (?v_778 (- x_186 cvclZero))) (let ((?v_784 (= ?v_778 0)) (?v_785 (= ?v_778 1)) (?v_789 (= ?v_778 2)) (?v_791 (= ?v_778 3)) (?v_854 (= (- x_156 x_101) 0)) (?v_865 (- x_187 x_132))) (let ((?v_809 (= ?v_865 0)) (?v_810 (= (- x_166 x_111) 0)) (?v_812 (= (- x_167 x_112) 0)) (?v_813 (= (- x_168 x_113) 0)) (?v_814 (= (- x_169 x_114) 0)) (?v_815 (= (- x_170 x_115) 0)) (?v_816 (= (- x_171 x_116) 0)) (?v_817 (= (- x_172 x_117) 0)) (?v_818 (= (- x_173 x_118) 0)) (?v_819 (= (- x_174 x_119) 0)) (?v_820 (= (- x_175 x_120) 0)) (?v_821 (= (- x_176 x_121) 0)) (?v_822 (= (- x_177 x_122) 0))) (let ((?v_853 (and (and (and (and (and (and (and (and (and (and (and ?v_810 ?v_812) ?v_813) ?v_814) ?v_815) ?v_816) ?v_817) ?v_818) ?v_819) ?v_820) ?v_821) ?v_822)) (?v_28 (- x_101 cvclZero))) (let ((?v_875 (= ?v_28 10)) (?v_811 (- x_157 cvclZero))) (let ((?v_836 (= ?v_811 0)) (?v_837 (= ?v_811 1)) (?v_838 (= ?v_811 2)) (?v_839 (= ?v_811 3)) (?v_840 (= ?v_811 4)) (?v_841 (= ?v_811 5)) (?v_842 (= ?v_811 6)) (?v_843 (= ?v_811 7)) (?v_844 (= ?v_811 8)) (?v_845 (= ?v_811 9)) (?v_846 (= ?v_811 10)) (?v_847 (= ?v_811 11)) (?v_879 (- x_131 cvclZero))) (let ((?v_885 (= ?v_879 0)) (?v_886 (= ?v_879 1)) (?v_890 (= ?v_879 2)) (?v_892 (= ?v_879 3)) (?v_955 (= (- x_101 x_46) 0)) (?v_966 (- x_132 x_77))) (let ((?v_910 (= ?v_966 0)) (?v_911 (= (- x_111 x_56) 0)) (?v_913 (= (- x_112 x_57) 0)) (?v_914 (= (- x_113 x_58) 0)) (?v_915 (= (- x_114 x_59) 0)) (?v_916 (= (- x_115 x_60) 0)) (?v_917 (= (- x_116 x_61) 0)) (?v_918 (= (- x_117 x_62) 0)) (?v_919 (= (- x_118 x_63) 0)) (?v_920 (= (- x_119 x_64) 0)) (?v_921 (= (- x_120 x_65) 0)) (?v_922 (= (- x_121 x_66) 0)) (?v_923 (= (- x_122 x_67) 0))) (let ((?v_954 (and (and (and (and (and (and (and (and (and (and (and ?v_911 ?v_913) ?v_914) ?v_915) ?v_916) ?v_917) ?v_918) ?v_919) ?v_920) ?v_921) ?v_922) ?v_923)) (?v_14 (- x_46 cvclZero))) (let ((?v_976 (= ?v_14 10)) (?v_912 (- x_102 cvclZero))) (let ((?v_937 (= ?v_912 0)) (?v_938 (= ?v_912 1)) (?v_939 (= ?v_912 2)) (?v_940 (= ?v_912 3)) (?v_941 (= ?v_912 4)) (?v_942 (= ?v_912 5)) (?v_943 (= ?v_912 6)) (?v_944 (= ?v_912 7)) (?v_945 (= ?v_912 8)) (?v_946 (= ?v_912 9)) (?v_947 (= ?v_912 10)) (?v_948 (= ?v_912 11)) (?v_982 (- x_76 cvclZero))) (let ((?v_986 (= ?v_982 0)) (?v_989 (= ?v_982 1)) (?v_992 (= ?v_982 2)) (?v_993 (= ?v_982 3)) (?v_1072 (= (- x_46 x_45) 0)) (?v_1075 (- x_77 x_44))) (let ((?v_1011 (= ?v_1075 0)) (?v_1016 (= (- x_56 x_32) 0)) (?v_1018 (= (- x_57 x_33) 0)) (?v_1019 (= (- x_58 x_34) 0)) (?v_1020 (= (- x_59 x_35) 0)) (?v_1021 (= (- x_60 x_36) 0)) (?v_1022 (= (- x_61 x_37) 0)) (?v_1023 (= (- x_62 x_38) 0)) (?v_1024 (= (- x_63 x_39) 0)) (?v_1025 (= (- x_64 x_40) 0)) (?v_1026 (= (- x_65 x_41) 0)) (?v_1027 (= (- x_66 x_42) 0)) (?v_1028 (= (- x_67 x_43) 0))) (let ((?v_1071 (and (and (and (and (and (and (and (and (and (and (and ?v_1016 ?v_1018) ?v_1019) ?v_1020) ?v_1021) ?v_1022) ?v_1023) ?v_1024) ?v_1025) ?v_1026) ?v_1027) ?v_1028)) (?v_13 (- x_45 cvclZero))) (let ((?v_1077 (= ?v_13 10)) (?v_1017 (- x_47 cvclZero))) (let ((?v_1046 (= ?v_1017 0)) (?v_1047 (= ?v_1017 1)) (?v_1048 (= ?v_1017 2)) (?v_1049 (= ?v_1017 3)) (?v_1050 (= ?v_1017 4)) (?v_1051 (= ?v_1017 5)) (?v_1052 (= ?v_1017 6)) (?v_1053 (= ?v_1017 7)) (?v_1054 (= ?v_1017 8)) (?v_1055 (= ?v_1017 9)) (?v_1056 (= ?v_1017 10)) (?v_1057 (= ?v_1017 11)) (?v_0 (- x_32 cvclZero)) (?v_1 (- x_33 cvclZero)) (?v_2 (- x_34 cvclZero)) (?v_3 (- x_35 cvclZero)) (?v_4 (- x_36 cvclZero)) (?v_5 (- x_37 cvclZero)) (?v_6 (- x_38 cvclZero)) (?v_7 (- x_39 cvclZero)) (?v_8 (- x_40 cvclZero)) (?v_9 (- x_41 cvclZero)) (?v_10 (- x_42 cvclZero)) (?v_11 (- x_43 cvclZero)) (?v_15 (- x_56 cvclZero)) (?v_16 (- x_57 cvclZero)) (?v_17 (- x_58 cvclZero)) (?v_18 (- x_59 cvclZero)) (?v_19 (- x_60 cvclZero)) (?v_20 (- x_61 cvclZero)) (?v_21 (- x_62 cvclZero)) (?v_22 (- x_63 cvclZero)) (?v_23 (- x_64 cvclZero)) (?v_24 (- x_65 cvclZero)) (?v_25 (- x_66 cvclZero)) (?v_26 (- x_67 cvclZero)) (?v_29 (- x_111 cvclZero)) (?v_30 (- x_112 cvclZero)) (?v_31 (- x_113 cvclZero)) (?v_32 (- x_114 cvclZero)) (?v_33 (- x_115 cvclZero)) (?v_34 (- x_116 cvclZero)) (?v_35 (- x_117 cvclZero)) (?v_36 (- x_118 cvclZero)) (?v_37 (- x_119 cvclZero)) (?v_38 (- x_120 cvclZero)) (?v_39 (- x_121 cvclZero)) (?v_40 (- x_122 cvclZero)) (?v_43 (- x_166 cvclZero)) (?v_44 (- x_167 cvclZero)) (?v_45 (- x_168 cvclZero)) (?v_46 (- x_169 cvclZero)) (?v_47 (- x_170 cvclZero)) (?v_48 (- x_171 cvclZero)) (?v_49 (- x_172 cvclZero)) (?v_50 (- x_173 cvclZero)) (?v_51 (- x_174 cvclZero)) (?v_52 (- x_175 cvclZero)) (?v_53 (- x_176 cvclZero)) (?v_54 (- x_177 cvclZero)) (?v_57 (- x_221 cvclZero)) (?v_58 (- x_222 cvclZero)) (?v_59 (- x_223 cvclZero)) (?v_60 (- x_224 cvclZero)) (?v_61 (- x_225 cvclZero)) (?v_62 (- x_226 cvclZero)) (?v_63 (- x_227 cvclZero)) (?v_64 (- x_228 cvclZero)) (?v_65 (- x_229 cvclZero)) (?v_66 (- x_230 cvclZero)) (?v_67 (- x_231 cvclZero)) (?v_68 (- x_232 cvclZero)) (?v_71 (- x_276 cvclZero)) (?v_72 (- x_277 cvclZero)) (?v_73 (- x_278 cvclZero)) (?v_74 (- x_279 cvclZero)) (?v_75 (- x_280 cvclZero)) (?v_76 (- x_281 cvclZero)) (?v_77 (- x_282 cvclZero)) (?v_78 (- x_283 cvclZero)) (?v_79 (- x_284 cvclZero)) (?v_80 (- x_285 cvclZero)) (?v_81 (- x_286 cvclZero)) (?v_82 (- x_287 cvclZero)) (?v_85 (- x_331 cvclZero)) (?v_86 (- x_332 cvclZero)) (?v_87 (- x_333 cvclZero)) (?v_88 (- x_334 cvclZero)) (?v_89 (- x_335 cvclZero)) (?v_90 (- x_336 cvclZero)) (?v_91 (- x_337 cvclZero)) (?v_92 (- x_338 cvclZero)) (?v_93 (- x_339 cvclZero)) (?v_94 (- x_340 cvclZero)) (?v_95 (- x_341 cvclZero)) (?v_96 (- x_342 cvclZero)) (?v_99 (- x_386 cvclZero)) (?v_100 (- x_387 cvclZero)) (?v_101 (- x_388 cvclZero)) (?v_102 (- x_389 cvclZero)) (?v_103 (- x_390 cvclZero)) (?v_104 (- x_391 cvclZero)) (?v_105 (- x_392 cvclZero)) (?v_106 (- x_393 cvclZero)) (?v_107 (- x_394 cvclZero)) (?v_108 (- x_395 cvclZero)) (?v_109 (- x_396 cvclZero)) (?v_110 (- x_397 cvclZero)) (?v_113 (- x_441 cvclZero)) (?v_114 (- x_442 cvclZero)) (?v_115 (- x_443 cvclZero)) (?v_116 (- x_444 cvclZero)) (?v_117 (- x_445 cvclZero)) (?v_118 (- x_446 cvclZero)) (?v_119 (- x_447 cvclZero)) (?v_120 (- x_448 cvclZero)) (?v_121 (- x_449 cvclZero)) (?v_122 (- x_450 cvclZero)) (?v_123 (- x_451 cvclZero)) (?v_124 (- x_452 cvclZero)) (?v_126 (- x_486 cvclZero)) (?v_127 (- x_496 cvclZero)) (?v_128 (- x_497 cvclZero)) (?v_129 (- x_498 cvclZero)) (?v_130 (- x_499 cvclZero)) (?v_131 (- x_500 cvclZero)) (?v_132 (- x_501 cvclZero)) (?v_133 (- x_502 cvclZero)) (?v_134 (- x_503 cvclZero)) (?v_135 (- x_504 cvclZero)) (?v_136 (- x_505 cvclZero)) (?v_137 (- x_506 cvclZero)) (?v_138 (- x_507 cvclZero)) (?v_139 (- x_517 cvclZero)) (?v_187 (- x_535 cvclZero)) (?v_150 (- x_536 cvclZero)) (?v_231 (- x_537 cvclZero)) (?v_214 (- x_538 cvclZero)) (?v_237 (- x_539 cvclZero)) (?v_240 (- x_518 cvclZero)) (?v_254 (- x_540 cvclZero)) (?v_303 (- x_480 cvclZero)) (?v_278 (- x_481 cvclZero)) (?v_347 (- x_482 cvclZero)) (?v_330 (- x_483 cvclZero)) (?v_352 (- x_484 cvclZero)) (?v_355 (- x_463 cvclZero)) (?v_363 (- x_485 cvclZero)) (?v_404 (- x_425 cvclZero)) (?v_379 (- x_426 cvclZero)) (?v_448 (- x_427 cvclZero)) (?v_431 (- x_428 cvclZero)) (?v_453 (- x_429 cvclZero)) (?v_456 (- x_408 cvclZero)) (?v_464 (- x_430 cvclZero)) (?v_505 (- x_370 cvclZero)) (?v_480 (- x_371 cvclZero)) (?v_549 (- x_372 cvclZero)) (?v_532 (- x_373 cvclZero)) (?v_554 (- x_374 cvclZero)) (?v_557 (- x_353 cvclZero)) (?v_565 (- x_375 cvclZero)) (?v_606 (- x_315 cvclZero)) (?v_581 (- x_316 cvclZero)) (?v_650 (- x_317 cvclZero)) (?v_633 (- x_318 cvclZero)) (?v_655 (- x_319 cvclZero)) (?v_658 (- x_298 cvclZero)) (?v_666 (- x_320 cvclZero)) (?v_707 (- x_260 cvclZero)) (?v_682 (- x_261 cvclZero)) (?v_751 (- x_262 cvclZero)) (?v_734 (- x_263 cvclZero)) (?v_756 (- x_264 cvclZero)) (?v_759 (- x_243 cvclZero)) (?v_767 (- x_265 cvclZero)) (?v_808 (- x_205 cvclZero)) (?v_783 (- x_206 cvclZero)) (?v_852 (- x_207 cvclZero)) (?v_835 (- x_208 cvclZero)) (?v_857 (- x_209 cvclZero)) (?v_860 (- x_188 cvclZero)) (?v_868 (- x_210 cvclZero)) (?v_909 (- x_150 cvclZero)) (?v_884 (- x_151 cvclZero)) (?v_953 (- x_152 cvclZero)) (?v_936 (- x_153 cvclZero)) (?v_958 (- x_154 cvclZero)) (?v_961 (- x_133 cvclZero)) (?v_969 (- x_155 cvclZero)) (?v_1010 (- x_95 cvclZero)) (?v_985 (- x_96 cvclZero)) (?v_1070 (- x_97 cvclZero)) (?v_1041 (- x_98 cvclZero)) (?v_1073 (- x_99 cvclZero)) (?v_1074 (- x_78 cvclZero)) (?v_1076 (- x_100 cvclZero))) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (not (< ?v_0 1)) (<= ?v_0 4)) (not (< ?v_1 1))) (<= ?v_1 4)) (not (< ?v_2 1))) (<= ?v_2 4)) (not (< ?v_3 1))) (<= ?v_3 4)) (not (< ?v_4 1))) (<= ?v_4 4)) (not (< ?v_5 1))) (<= ?v_5 4)) (not (< ?v_6 1))) (<= ?v_6 4)) (not (< ?v_7 1))) (<= ?v_7 4)) (not (< ?v_8 1))) (<= ?v_8 4)) (not (< ?v_9 1))) (<= ?v_9 4)) (not (< ?v_10 1))) (<= ?v_10 4)) (not (< ?v_11 1))) (<= ?v_11 4)) (not (< ?v_12 0))) (<= ?v_12 11)) (not (< ?v_13 0))) (<= ?v_13 11)) (not (< ?v_14 0))) (<= ?v_14 11)) (not (< ?v_15 1))) (<= ?v_15 4)) (not (< ?v_16 1))) (<= ?v_16 4)) (not (< ?v_17 1))) (<= ?v_17 4)) (not (< ?v_18 1))) (<= ?v_18 4)) (not (< ?v_19 1))) (<= ?v_19 4)) (not (< ?v_20 1))) (<= ?v_20 4)) (not (< ?v_21 1))) (<= ?v_21 4)) (not (< ?v_22 1))) (<= ?v_22 4)) (not (< ?v_23 1))) (<= ?v_23 4)) (not (< ?v_24 1))) (<= ?v_24 4)) (not (< ?v_25 1))) (<= ?v_25 4)) (not (< ?v_26 1))) (<= ?v_26 4)) (not (< ?v_27 0))) (<= ?v_27 11)) (not (< ?v_28 0))) (<= ?v_28 11)) (not (< ?v_29 1))) (<= ?v_29 4)) (not (< ?v_30 1))) (<= ?v_30 4)) (not (< ?v_31 1))) (<= ?v_31 4)) (not (< ?v_32 1))) (<= ?v_32 4)) (not (< ?v_33 1))) (<= ?v_33 4)) (not (< ?v_34 1))) (<= ?v_34 4)) (not (< ?v_35 1))) (<= ?v_35 4)) (not (< ?v_36 1))) (<= ?v_36 4)) (not (< ?v_37 1))) (<= ?v_37 4)) (not (< ?v_38 1))) (<= ?v_38 4)) (not (< ?v_39 1))) (<= ?v_39 4)) (not (< ?v_40 1))) (<= ?v_40 4)) (not (< ?v_41 0))) (<= ?v_41 11)) (not (< ?v_42 0))) (<= ?v_42 11)) (not (< ?v_43 1))) (<= ?v_43 4)) (not (< ?v_44 1))) (<= ?v_44 4)) (not (< ?v_45 1))) (<= ?v_45 4)) (not (< ?v_46 1))) (<= ?v_46 4)) (not (< ?v_47 1))) (<= ?v_47 4)) (not (< ?v_48 1))) (<= ?v_48 4)) (not (< ?v_49 1))) (<= ?v_49 4)) (not (< ?v_50 1))) (<= ?v_50 4)) (not (< ?v_51 1))) (<= ?v_51 4)) (not (< ?v_52 1))) (<= ?v_52 4)) (not (< ?v_53 1))) (<= ?v_53 4)) (not (< ?v_54 1))) (<= ?v_54 4)) (not (< ?v_55 0))) (<= ?v_55 11)) (not (< ?v_56 0))) (<= ?v_56 11)) (not (< ?v_57 1))) (<= ?v_57 4)) (not (< ?v_58 1))) (<= ?v_58 4)) (not (< ?v_59 1))) (<= ?v_59 4)) (not (< ?v_60 1))) (<= ?v_60 4)) (not (< ?v_61 1))) (<= ?v_61 4)) (not (< ?v_62 1))) (<= ?v_62 4)) (not (< ?v_63 1))) (<= ?v_63 4)) (not (< ?v_64 1))) (<= ?v_64 4)) (not (< ?v_65 1))) (<= ?v_65 4)) (not (< ?v_66 1))) (<= ?v_66 4)) (not (< ?v_67 1))) (<= ?v_67 4)) (not (< ?v_68 1))) (<= ?v_68 4)) (not (< ?v_69 0))) (<= ?v_69 11)) (not (< ?v_70 0))) (<= ?v_70 11)) (not (< ?v_71 1))) (<= ?v_71 4)) (not (< ?v_72 1))) (<= ?v_72 4)) (not (< ?v_73 1))) (<= ?v_73 4)) (not (< ?v_74 1))) (<= ?v_74 4)) (not (< ?v_75 1))) (<= ?v_75 4)) (not (< ?v_76 1))) (<= ?v_76 4)) (not (< ?v_77 1))) (<= ?v_77 4)) (not (< ?v_78 1))) (<= ?v_78 4)) (not (< ?v_79 1))) (<= ?v_79 4)) (not (< ?v_80 1))) (<= ?v_80 4)) (not (< ?v_81 1))) (<= ?v_81 4)) (not (< ?v_82 1))) (<= ?v_82 4)) (not (< ?v_83 0))) (<= ?v_83 11)) (not (< ?v_84 0))) (<= ?v_84 11)) (not (< ?v_85 1))) (<= ?v_85 4)) (not (< ?v_86 1))) (<= ?v_86 4)) (not (< ?v_87 1))) (<= ?v_87 4)) (not (< ?v_88 1))) (<= ?v_88 4)) (not (< ?v_89 1))) (<= ?v_89 4)) (not (< ?v_90 1))) (<= ?v_90 4)) (not (< ?v_91 1))) (<= ?v_91 4)) (not (< ?v_92 1))) (<= ?v_92 4)) (not (< ?v_93 1))) (<= ?v_93 4)) (not (< ?v_94 1))) (<= ?v_94 4)) (not (< ?v_95 1))) (<= ?v_95 4)) (not (< ?v_96 1))) (<= ?v_96 4)) (not (< ?v_97 0))) (<= ?v_97 11)) (not (< ?v_98 0))) (<= ?v_98 11)) (not (< ?v_99 1))) (<= ?v_99 4)) (not (< ?v_100 1))) (<= ?v_100 4)) (not (< ?v_101 1))) (<= ?v_101 4)) (not (< ?v_102 1))) (<= ?v_102 4)) (not (< ?v_103 1))) (<= ?v_103 4)) (not (< ?v_104 1))) (<= ?v_104 4)) (not (< ?v_105 1))) (<= ?v_105 4)) (not (< ?v_106 1))) (<= ?v_106 4)) (not (< ?v_107 1))) (<= ?v_107 4)) (not (< ?v_108 1))) (<= ?v_108 4)) (not (< ?v_109 1))) (<= ?v_109 4)) (not (< ?v_110 1))) (<= ?v_110 4)) (not (< ?v_111 0))) (<= ?v_111 11)) (not (< ?v_112 0))) (<= ?v_112 11)) (not (< ?v_113 1))) (<= ?v_113 4)) (not (< ?v_114 1))) (<= ?v_114 4)) (not (< ?v_115 1))) (<= ?v_115 4)) (not (< ?v_116 1))) (<= ?v_116 4)) (not (< ?v_117 1))) (<= ?v_117 4)) (not (< ?v_118 1))) (<= ?v_118 4)) (not (< ?v_119 1))) (<= ?v_119 4)) (not (< ?v_120 1))) (<= ?v_120 4)) (not (< ?v_121 1))) (<= ?v_121 4)) (not (< ?v_122 1))) (<= ?v_122 4)) (not (< ?v_123 1))) (<= ?v_123 4)) (not (< ?v_124 1))) (<= ?v_124 4)) (not (< ?v_125 0))) (<= ?v_125 11)) (not (< ?v_126 0))) (<= ?v_126 11)) (not (< ?v_127 1))) (<= ?v_127 4)) (not (< ?v_128 1))) (<= ?v_128 4)) (not (< ?v_129 1))) (<= ?v_129 4)) (not (< ?v_130 1))) (<= ?v_130 4)) (not (< ?v_131 1))) (<= ?v_131 4)) (not (< ?v_132 1))) (<= ?v_132 4)) (not (< ?v_133 1))) (<= ?v_133 4)) (not (< ?v_134 1))) (<= ?v_134 4)) (not (< ?v_135 1))) (<= ?v_135 4)) (not (< ?v_136 1))) (<= ?v_136 4)) (not (< ?v_137 1))) (<= ?v_137 4)) (not (< ?v_138 1))) (<= ?v_138 4)) (not (< ?v_139 0))) (<= ?v_139 11)) (and ?v_980 ?v_981)) (and ?v_987 ?v_988)) (and ?v_1000 ?v_1001)) (and ?v_1006 ?v_1007)) (and ?v_1012 ?v_1013)) (and ?v_1042 ?v_1043)) (and ?v_1062 ?v_1063)) (and ?v_1066 ?v_1067)) (and x_16 x_17)) (and x_18 x_19)) (and x_20 x_21)) (and x_22 x_23)) (and ?v_1014 ?v_1015)) (and ?v_1044 ?v_1045)) (and ?v_1064 ?v_1065)) (and ?v_1068 ?v_1069)) (= ?v_0 1)) (= ?v_1 1)) (= ?v_2 1)) (= ?v_3 1)) (= ?v_4 1)) (= ?v_5 1)) (= ?v_6 1)) (= ?v_7 1)) (= ?v_8 1)) (= ?v_9 1)) (= ?v_10 1)) (= ?v_11 1)) ?v_140) (= ?v_13 0)) (= (- x_47 x_45) 1)) (ite (= ?v_12 11) (= (- x_78 x_43) 0) (ite (= ?v_12 10) (= (- x_78 x_42) 0) (ite (= ?v_12 9) (= (- x_78 x_41) 0) (ite (= ?v_12 8) (= (- x_78 x_40) 0) (ite (= ?v_12 7) (= (- x_78 x_39) 0) (ite (= ?v_12 6) (= (- x_78 x_38) 0) (ite (= ?v_12 5) (= (- x_78 x_37) 0) (ite (= ?v_12 4) (= (- x_78 x_36) 0) (ite (= ?v_12 3) (= (- x_78 x_35) 0) (ite (= ?v_12 2) (= (- x_78 x_34) 0) (ite ?v_140 (= (- x_78 x_33) 0) (= (- x_78 x_32) 0))))))))))))) (= (- x_102 x_46) 1)) (ite (= ?v_27 11) (= (- x_133 x_67) 0) (ite (= ?v_27 10) (= (- x_133 x_66) 0) (ite (= ?v_27 9) (= (- x_133 x_65) 0) (ite (= ?v_27 8) (= (- x_133 x_64) 0) (ite (= ?v_27 7) (= (- x_133 x_63) 0) (ite (= ?v_27 6) (= (- x_133 x_62) 0) (ite (= ?v_27 5) (= (- x_133 x_61) 0) (ite (= ?v_27 4) (= (- x_133 x_60) 0) (ite (= ?v_27 3) (= (- x_133 x_59) 0) (ite (= ?v_27 2) (= (- x_133 x_58) 0) (ite ?v_1078 (= (- x_133 x_57) 0) (= (- x_133 x_56) 0))))))))))))) (= (- x_157 x_101) 1)) (ite (= ?v_41 11) (= (- x_188 x_122) 0) (ite (= ?v_41 10) (= (- x_188 x_121) 0) (ite (= ?v_41 9) (= (- x_188 x_120) 0) (ite (= ?v_41 8) (= (- x_188 x_119) 0) (ite (= ?v_41 7) (= (- x_188 x_118) 0) (ite (= ?v_41 6) (= (- x_188 x_117) 0) (ite (= ?v_41 5) (= (- x_188 x_116) 0) (ite (= ?v_41 4) (= (- x_188 x_115) 0) (ite (= ?v_41 3) (= (- x_188 x_114) 0) (ite (= ?v_41 2) (= (- x_188 x_113) 0) (ite ?v_977 (= (- x_188 x_112) 0) (= (- x_188 x_111) 0))))))))))))) (= (- x_212 x_156) 1)) (ite (= ?v_55 11) (= (- x_243 x_177) 0) (ite (= ?v_55 10) (= (- x_243 x_176) 0) (ite (= ?v_55 9) (= (- x_243 x_175) 0) (ite (= ?v_55 8) (= (- x_243 x_174) 0) (ite (= ?v_55 7) (= (- x_243 x_173) 0) (ite (= ?v_55 6) (= (- x_243 x_172) 0) (ite (= ?v_55 5) (= (- x_243 x_171) 0) (ite (= ?v_55 4) (= (- x_243 x_170) 0) (ite (= ?v_55 3) (= (- x_243 x_169) 0) (ite (= ?v_55 2) (= (- x_243 x_168) 0) (ite ?v_876 (= (- x_243 x_167) 0) (= (- x_243 x_166) 0))))))))))))) (= (- x_267 x_211) 1)) (ite (= ?v_69 11) (= (- x_298 x_232) 0) (ite (= ?v_69 10) (= (- x_298 x_231) 0) (ite (= ?v_69 9) (= (- x_298 x_230) 0) (ite (= ?v_69 8) (= (- x_298 x_229) 0) (ite (= ?v_69 7) (= (- x_298 x_228) 0) (ite (= ?v_69 6) (= (- x_298 x_227) 0) (ite (= ?v_69 5) (= (- x_298 x_226) 0) (ite (= ?v_69 4) (= (- x_298 x_225) 0) (ite (= ?v_69 3) (= (- x_298 x_224) 0) (ite (= ?v_69 2) (= (- x_298 x_223) 0) (ite ?v_775 (= (- x_298 x_222) 0) (= (- x_298 x_221) 0))))))))))))) (= (- x_322 x_266) 1)) (ite (= ?v_83 11) (= (- x_353 x_287) 0) (ite (= ?v_83 10) (= (- x_353 x_286) 0) (ite (= ?v_83 9) (= (- x_353 x_285) 0) (ite (= ?v_83 8) (= (- x_353 x_284) 0) (ite (= ?v_83 7) (= (- x_353 x_283) 0) (ite (= ?v_83 6) (= (- x_353 x_282) 0) (ite (= ?v_83 5) (= (- x_353 x_281) 0) (ite (= ?v_83 4) (= (- x_353 x_280) 0) (ite (= ?v_83 3) (= (- x_353 x_279) 0) (ite (= ?v_83 2) (= (- x_353 x_278) 0) (ite ?v_674 (= (- x_353 x_277) 0) (= (- x_353 x_276) 0))))))))))))) (= (- x_377 x_321) 1)) (ite (= ?v_97 11) (= (- x_408 x_342) 0) (ite (= ?v_97 10) (= (- x_408 x_341) 0) (ite (= ?v_97 9) (= (- x_408 x_340) 0) (ite (= ?v_97 8) (= (- x_408 x_339) 0) (ite (= ?v_97 7) (= (- x_408 x_338) 0) (ite (= ?v_97 6) (= (- x_408 x_337) 0) (ite (= ?v_97 5) (= (- x_408 x_336) 0) (ite (= ?v_97 4) (= (- x_408 x_335) 0) (ite (= ?v_97 3) (= (- x_408 x_334) 0) (ite (= ?v_97 2) (= (- x_408 x_333) 0) (ite ?v_573 (= (- x_408 x_332) 0) (= (- x_408 x_331) 0))))))))))))) (= (- x_432 x_376) 1)) (ite (= ?v_111 11) (= (- x_463 x_397) 0) (ite (= ?v_111 10) (= (- x_463 x_396) 0) (ite (= ?v_111 9) (= (- x_463 x_395) 0) (ite (= ?v_111 8) (= (- x_463 x_394) 0) (ite (= ?v_111 7) (= (- x_463 x_393) 0) (ite (= ?v_111 6) (= (- x_463 x_392) 0) (ite (= ?v_111 5) (= (- x_463 x_391) 0) (ite (= ?v_111 4) (= (- x_463 x_390) 0) (ite (= ?v_111 3) (= (- x_463 x_389) 0) (ite (= ?v_111 2) (= (- x_463 x_388) 0) (ite ?v_472 (= (- x_463 x_387) 0) (= (- x_463 x_386) 0))))))))))))) (= (- x_487 x_431) 1)) (ite (= ?v_125 11) (= (- x_518 x_452) 0) (ite (= ?v_125 10) (= (- x_518 x_451) 0) (ite (= ?v_125 9) (= (- x_518 x_450) 0) (ite (= ?v_125 8) (= (- x_518 x_449) 0) (ite (= ?v_125 7) (= (- x_518 x_448) 0) (ite (= ?v_125 6) (= (- x_518 x_447) 0) (ite (= ?v_125 5) (= (- x_518 x_446) 0) (ite (= ?v_125 4) (= (- x_518 x_445) 0) (ite (= ?v_125 3) (= (- x_518 x_444) 0) (ite (= ?v_125 2) (= (- x_518 x_443) 0) (ite ?v_371 (= (- x_518 x_442) 0) (= (- x_518 x_441) 0))))))))))))) (or (and (and (and (and (and (and (= ?v_187 0) (or (or (or (and (and (and (and (and (and (and (= ?v_150 1) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_144) ?v_142) ?v_145) ?v_143) x_519) ?v_147) x_527) ?v_149) (and (and (and (and (and (and (and ?v_152 x_464) ?v_142) x_433) ?v_143) ?v_146) x_520) ?v_164)) (and (and (and (and (and (and ?v_156 ?v_144) x_465) x_519) x_520) ?v_148) x_528)) (and (and (and (and (and (and (and (and ?v_158 x_464) x_465) ?v_145) x_434) ?v_146) ?v_147) ?v_148) ?v_149))) ?v_178) ?v_155) ?v_165) ?v_166) ?v_167) ?v_168) (and (and (and (and (and (and (and (= ?v_150 2) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_157) ?v_153) ?v_159) ?v_154) x_521) ?v_161) x_529) ?v_163) (and (and (and (and (and (and (and ?v_152 x_466) ?v_153) x_435) ?v_154) ?v_160) x_522) ?v_155)) (and (and (and (and (and (and ?v_156 ?v_157) x_467) x_521) x_522) ?v_162) x_530)) (and (and (and (and (and (and (and (and ?v_158 x_466) x_467) ?v_159) x_436) ?v_160) ?v_161) ?v_162) ?v_163))) ?v_177) ?v_164) ?v_165) ?v_166) ?v_167) ?v_168)) (and (and (and (and (and (and (and (= ?v_150 3) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_171) ?v_169) ?v_172) ?v_170) x_523) ?v_174) x_531) ?v_176) (and (and (and (and (and (and (and ?v_152 x_468) ?v_169) x_437) ?v_170) ?v_173) x_524) ?v_166)) (and (and (and (and (and (and ?v_156 ?v_171) x_469) x_523) x_524) ?v_175) x_532)) (and (and (and (and (and (and (and (and ?v_158 x_468) x_469) ?v_172) x_438) ?v_173) ?v_174) ?v_175) ?v_176))) ?v_177) ?v_164) ?v_178) ?v_155) ?v_167) ?v_168)) (and (and (and (and (and (and (and (= ?v_150 4) (or (or (or (and (and (and (and (and (and (and (and ?v_151 ?v_181) ?v_179) ?v_182) ?v_180) x_525) ?v_184) x_533) ?v_186) (and (and (and (and (and (and (and ?v_152 x_470) ?v_179) x_439) ?v_180) ?v_183) x_526) ?v_168)) (and (and (and (and (and (and ?v_156 ?v_181) x_471) x_525) x_526) ?v_185) x_534)) (and (and (and (and (and (and (and (and ?v_158 x_470) x_471) ?v_182) x_440) ?v_183) ?v_184) ?v_185) ?v_186))) ?v_177) ?v_164) ?v_178) ?v_155) ?v_165) ?v_166))) ?v_233) ?v_188) ?v_232) ?v_272) ?v_271) (and (and (and (and (and (and (and (and (and (= ?v_187 1) (or (or (or (and (and (and (and (= ?v_231 0) (not ?v_270)) (= (- x_486 x_487) 0)) ?v_188) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 1) ?v_249) ?v_234) ?v_250) ?v_235) (ite ?v_215 (= ?v_127 1) ?v_189)) (ite ?v_216 (= ?v_128 1) ?v_191)) (ite ?v_217 (= ?v_129 1) ?v_192)) (ite ?v_218 (= ?v_130 1) ?v_193)) (ite ?v_219 (= ?v_131 1) ?v_194)) (ite ?v_220 (= ?v_132 1) ?v_195)) (ite ?v_221 (= ?v_133 1) ?v_196)) (ite ?v_222 (= ?v_134 1) ?v_197)) (ite ?v_223 (= ?v_135 1) ?v_198)) (ite ?v_224 (= ?v_136 1) ?v_199)) (ite ?v_225 (= ?v_137 1) ?v_200)) (ite ?v_226 (= ?v_138 1) ?v_201)) x_508) ?v_252) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207) ?v_253) ?v_236) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 2) ?v_255) ?v_238) ?v_256) ?v_239) (ite ?v_215 (= ?v_127 2) ?v_189)) (ite ?v_216 (= ?v_128 2) ?v_191)) (ite ?v_217 (= ?v_129 2) ?v_192)) (ite ?v_218 (= ?v_130 2) ?v_193)) (ite ?v_219 (= ?v_131 2) ?v_194)) (ite ?v_220 (= ?v_132 2) ?v_195)) (ite ?v_221 (= ?v_133 2) ?v_196)) (ite ?v_222 (= ?v_134 2) ?v_197)) (ite ?v_223 (= ?v_135 2) ?v_198)) (ite ?v_224 (= ?v_136 2) ?v_199)) (ite ?v_225 (= ?v_137 2) ?v_200)) (ite ?v_226 (= ?v_138 2) ?v_201)) ?v_227) ?v_228) x_510) ?v_258) ?v_204) ?v_205) ?v_206) ?v_207) ?v_229) ?v_230) ?v_259) ?v_241) ?v_210) ?v_211) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 3) ?v_260) ?v_242) ?v_261) ?v_243) (ite ?v_215 (= ?v_127 3) ?v_189)) (ite ?v_216 (= ?v_128 3) ?v_191)) (ite ?v_217 (= ?v_129 3) ?v_192)) (ite ?v_218 (= ?v_130 3) ?v_193)) (ite ?v_219 (= ?v_131 3) ?v_194)) (ite ?v_220 (= ?v_132 3) ?v_195)) (ite ?v_221 (= ?v_133 3) ?v_196)) (ite ?v_222 (= ?v_134 3) ?v_197)) (ite ?v_223 (= ?v_135 3) ?v_198)) (ite ?v_224 (= ?v_136 3) ?v_199)) (ite ?v_225 (= ?v_137 3) ?v_200)) (ite ?v_226 (= ?v_138 3) ?v_201)) ?v_227) ?v_228) ?v_202) ?v_203) x_512) ?v_263) ?v_206) ?v_207) ?v_229) ?v_230) ?v_208) ?v_209) ?v_264) ?v_244) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_214 4) ?v_265) ?v_245) ?v_266) ?v_246) (ite ?v_215 (= ?v_127 4) ?v_189)) (ite ?v_216 (= ?v_128 4) ?v_191)) (ite ?v_217 (= ?v_129 4) ?v_192)) (ite ?v_218 (= ?v_130 4) ?v_193)) (ite ?v_219 (= ?v_131 4) ?v_194)) (ite ?v_220 (= ?v_132 4) ?v_195)) (ite ?v_221 (= ?v_133 4) ?v_196)) (ite ?v_222 (= ?v_134 4) ?v_197)) (ite ?v_223 (= ?v_135 4) ?v_198)) (ite ?v_224 (= ?v_136 4) ?v_199)) (ite ?v_225 (= ?v_137 4) ?v_200)) (ite ?v_226 (= ?v_138 4) ?v_201)) ?v_227) ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) x_514) ?v_268) ?v_229) ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) ?v_269) ?v_247))) (and (and (and (and (= ?v_231 1) ?v_232) ?v_188) ?v_233) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 1) x_472) ?v_234) x_453) ?v_235) (= ?v_240 1)) ?v_251) x_509) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207) x_488) ?v_236) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 2) x_474) ?v_238) x_455) ?v_239) (= ?v_240 2)) ?v_227) ?v_228) ?v_257) x_511) ?v_204) ?v_205) ?v_206) ?v_207) ?v_229) ?v_230) x_490) ?v_241) ?v_210) ?v_211) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 3) x_476) ?v_242) x_457) ?v_243) (= ?v_240 3)) ?v_227) ?v_228) ?v_202) ?v_203) ?v_262) x_513) ?v_206) ?v_207) ?v_229) ?v_230) ?v_208) ?v_209) x_492) ?v_244) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_237 4) x_478) ?v_245) x_459) ?v_246) (= ?v_240 4)) ?v_227) ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) ?v_267) x_515) ?v_229) ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) x_494) ?v_247)))) (and (and (and (and (= ?v_231 2) (= ?v_248 1)) ?v_232) ?v_233) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 1) ?v_249) x_473) ?v_250) x_454) ?v_251) ?v_252) ?v_202) ?v_203) ?v_204) ?v_205) ?v_206) ?v_207) ?v_253) x_489) ?v_208) ?v_209) ?v_210) ?v_211) ?v_212) ?v_213) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 2) ?v_255) x_475) ?v_256) x_456) ?v_227) ?v_228) ?v_257) ?v_258) ?v_204) ?v_205) ?v_206) ?v_207) ?v_229) ?v_230) ?v_259) x_491) ?v_210) ?v_211) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 3) ?v_260) x_477) ?v_261) x_458) ?v_227) ?v_228) ?v_202) ?v_203) ?v_262) ?v_263) ?v_206) ?v_207) ?v_229) ?v_230) ?v_208) ?v_209) ?v_264) x_493) ?v_212) ?v_213)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_254 4) ?v_265) x_479) ?v_266) x_460) ?v_227) ?v_228) ?v_202) ?v_203) ?v_204) ?v_205) ?v_267) ?v_268) ?v_229) ?v_230) ?v_208) ?v_209) ?v_210) ?v_211) ?v_269) x_495)))) (and (and (and (and (and (and (and (= ?v_231 3) (= (- x_462 x_487) 0)) ?v_270) (= ?v_139 1)) (= ?v_126 0)) ?v_271) ?v_232) ?v_272))) ?v_177) ?v_178) ?v_165) ?v_167) ?v_164) ?v_155) ?v_166) ?v_168))) (or (and (and (and (and (and (and (= ?v_303 0) (or (or (or (and (and (and (and (and (and (and (= ?v_278 1) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_276) ?v_274) ?v_277) ?v_275) x_464) ?v_142) x_472) ?v_234) (and (and (and (and (and (and (and ?v_280 x_409) ?v_274) x_378) ?v_275) ?v_144) x_465) ?v_288)) (and (and (and (and (and (and ?v_284 ?v_276) x_410) x_464) x_465) ?v_249) x_473)) (and (and (and (and (and (and (and (and ?v_286 x_409) x_410) ?v_277) x_379) ?v_144) ?v_142) ?v_249) ?v_234))) ?v_298) ?v_283) ?v_289) ?v_290) ?v_291) ?v_292) (and (and (and (and (and (and (and (= ?v_278 2) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_285) ?v_281) ?v_287) ?v_282) x_466) ?v_153) x_474) ?v_238) (and (and (and (and (and (and (and ?v_280 x_411) ?v_281) x_380) ?v_282) ?v_157) x_467) ?v_283)) (and (and (and (and (and (and ?v_284 ?v_285) x_412) x_466) x_467) ?v_255) x_475)) (and (and (and (and (and (and (and (and ?v_286 x_411) x_412) ?v_287) x_381) ?v_157) ?v_153) ?v_255) ?v_238))) ?v_297) ?v_288) ?v_289) ?v_290) ?v_291) ?v_292)) (and (and (and (and (and (and (and (= ?v_278 3) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_295) ?v_293) ?v_296) ?v_294) x_468) ?v_169) x_476) ?v_242) (and (and (and (and (and (and (and ?v_280 x_413) ?v_293) x_382) ?v_294) ?v_171) x_469) ?v_290)) (and (and (and (and (and (and ?v_284 ?v_295) x_414) x_468) x_469) ?v_260) x_477)) (and (and (and (and (and (and (and (and ?v_286 x_413) x_414) ?v_296) x_383) ?v_171) ?v_169) ?v_260) ?v_242))) ?v_297) ?v_288) ?v_298) ?v_283) ?v_291) ?v_292)) (and (and (and (and (and (and (and (= ?v_278 4) (or (or (or (and (and (and (and (and (and (and (and ?v_279 ?v_301) ?v_299) ?v_302) ?v_300) x_470) ?v_179) x_478) ?v_245) (and (and (and (and (and (and (and ?v_280 x_415) ?v_299) x_384) ?v_300) ?v_181) x_471) ?v_292)) (and (and (and (and (and (and ?v_284 ?v_301) x_416) x_470) x_471) ?v_265) x_479)) (and (and (and (and (and (and (and (and ?v_286 x_415) x_416) ?v_302) x_385) ?v_181) ?v_179) ?v_265) ?v_245))) ?v_297) ?v_288) ?v_298) ?v_283) ?v_289) ?v_290))) ?v_349) ?v_304) ?v_348) ?v_373) ?v_372) (and (and (and (and (and (and (and (and (and (= ?v_303 1) (or (or (or (and (and (and (and (= ?v_347 0) (not ?v_370)) (= (- x_431 x_432) 0)) ?v_304) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 1) ?v_361) ?v_350) ?v_362) ?v_351) (ite ?v_331 (= ?v_113 1) ?v_305)) (ite ?v_332 (= ?v_114 1) ?v_307)) (ite ?v_333 (= ?v_115 1) ?v_308)) (ite ?v_334 (= ?v_116 1) ?v_309)) (ite ?v_335 (= ?v_117 1) ?v_310)) (ite ?v_336 (= ?v_118 1) ?v_311)) (ite ?v_337 (= ?v_119 1) ?v_312)) (ite ?v_338 (= ?v_120 1) ?v_313)) (ite ?v_339 (= ?v_121 1) ?v_314)) (ite ?v_340 (= ?v_122 1) ?v_315)) (ite ?v_341 (= ?v_123 1) ?v_316)) (ite ?v_342 (= ?v_124 1) ?v_317)) x_453) ?v_235) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323) ?v_145) ?v_143) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 2) ?v_364) ?v_353) ?v_365) ?v_354) (ite ?v_331 (= ?v_113 2) ?v_305)) (ite ?v_332 (= ?v_114 2) ?v_307)) (ite ?v_333 (= ?v_115 2) ?v_308)) (ite ?v_334 (= ?v_116 2) ?v_309)) (ite ?v_335 (= ?v_117 2) ?v_310)) (ite ?v_336 (= ?v_118 2) ?v_311)) (ite ?v_337 (= ?v_119 2) ?v_312)) (ite ?v_338 (= ?v_120 2) ?v_313)) (ite ?v_339 (= ?v_121 2) ?v_314)) (ite ?v_340 (= ?v_122 2) ?v_315)) (ite ?v_341 (= ?v_123 2) ?v_316)) (ite ?v_342 (= ?v_124 2) ?v_317)) ?v_343) ?v_344) x_455) ?v_239) ?v_320) ?v_321) ?v_322) ?v_323) ?v_345) ?v_346) ?v_159) ?v_154) ?v_326) ?v_327) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 3) ?v_366) ?v_356) ?v_367) ?v_357) (ite ?v_331 (= ?v_113 3) ?v_305)) (ite ?v_332 (= ?v_114 3) ?v_307)) (ite ?v_333 (= ?v_115 3) ?v_308)) (ite ?v_334 (= ?v_116 3) ?v_309)) (ite ?v_335 (= ?v_117 3) ?v_310)) (ite ?v_336 (= ?v_118 3) ?v_311)) (ite ?v_337 (= ?v_119 3) ?v_312)) (ite ?v_338 (= ?v_120 3) ?v_313)) (ite ?v_339 (= ?v_121 3) ?v_314)) (ite ?v_340 (= ?v_122 3) ?v_315)) (ite ?v_341 (= ?v_123 3) ?v_316)) (ite ?v_342 (= ?v_124 3) ?v_317)) ?v_343) ?v_344) ?v_318) ?v_319) x_457) ?v_243) ?v_322) ?v_323) ?v_345) ?v_346) ?v_324) ?v_325) ?v_172) ?v_170) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_330 4) ?v_368) ?v_358) ?v_369) ?v_359) (ite ?v_331 (= ?v_113 4) ?v_305)) (ite ?v_332 (= ?v_114 4) ?v_307)) (ite ?v_333 (= ?v_115 4) ?v_308)) (ite ?v_334 (= ?v_116 4) ?v_309)) (ite ?v_335 (= ?v_117 4) ?v_310)) (ite ?v_336 (= ?v_118 4) ?v_311)) (ite ?v_337 (= ?v_119 4) ?v_312)) (ite ?v_338 (= ?v_120 4) ?v_313)) (ite ?v_339 (= ?v_121 4) ?v_314)) (ite ?v_340 (= ?v_122 4) ?v_315)) (ite ?v_341 (= ?v_123 4) ?v_316)) (ite ?v_342 (= ?v_124 4) ?v_317)) ?v_343) ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) x_459) ?v_246) ?v_345) ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) ?v_182) ?v_180))) (and (and (and (and (= ?v_347 1) ?v_348) ?v_304) ?v_349) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 1) x_417) ?v_350) x_398) ?v_351) (= ?v_355 1)) ?v_250) x_454) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323) x_433) ?v_143) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 2) x_419) ?v_353) x_400) ?v_354) (= ?v_355 2)) ?v_343) ?v_344) ?v_256) x_456) ?v_320) ?v_321) ?v_322) ?v_323) ?v_345) ?v_346) x_435) ?v_154) ?v_326) ?v_327) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 3) x_421) ?v_356) x_402) ?v_357) (= ?v_355 3)) ?v_343) ?v_344) ?v_318) ?v_319) ?v_261) x_458) ?v_322) ?v_323) ?v_345) ?v_346) ?v_324) ?v_325) x_437) ?v_170) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_352 4) x_423) ?v_358) x_404) ?v_359) (= ?v_355 4)) ?v_343) ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) ?v_266) x_460) ?v_345) ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) x_439) ?v_180)))) (and (and (and (and (= ?v_347 2) (= ?v_360 1)) ?v_348) ?v_349) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 1) ?v_361) x_418) ?v_362) x_399) ?v_250) ?v_235) ?v_318) ?v_319) ?v_320) ?v_321) ?v_322) ?v_323) ?v_145) x_434) ?v_324) ?v_325) ?v_326) ?v_327) ?v_328) ?v_329) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 2) ?v_364) x_420) ?v_365) x_401) ?v_343) ?v_344) ?v_256) ?v_239) ?v_320) ?v_321) ?v_322) ?v_323) ?v_345) ?v_346) ?v_159) x_436) ?v_326) ?v_327) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 3) ?v_366) x_422) ?v_367) x_403) ?v_343) ?v_344) ?v_318) ?v_319) ?v_261) ?v_243) ?v_322) ?v_323) ?v_345) ?v_346) ?v_324) ?v_325) ?v_172) x_438) ?v_328) ?v_329)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_363 4) ?v_368) x_424) ?v_369) x_405) ?v_343) ?v_344) ?v_318) ?v_319) ?v_320) ?v_321) ?v_266) ?v_246) ?v_345) ?v_346) ?v_324) ?v_325) ?v_326) ?v_327) ?v_182) x_440)))) (and (and (and (and (and (and (and (= ?v_347 3) (= (- x_407 x_432) 0)) ?v_370) ?v_371) (= ?v_112 0)) ?v_372) ?v_348) ?v_373))) ?v_297) ?v_298) ?v_289) ?v_291) ?v_288) ?v_283) ?v_290) ?v_292))) (or (and (and (and (and (and (and (= ?v_404 0) (or (or (or (and (and (and (and (and (and (and (= ?v_379 1) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_377) ?v_375) ?v_378) ?v_376) x_409) ?v_274) x_417) ?v_350) (and (and (and (and (and (and (and ?v_381 x_354) ?v_375) x_323) ?v_376) ?v_276) x_410) ?v_389)) (and (and (and (and (and (and ?v_385 ?v_377) x_355) x_409) x_410) ?v_361) x_418)) (and (and (and (and (and (and (and (and ?v_387 x_354) x_355) ?v_378) x_324) ?v_276) ?v_274) ?v_361) ?v_350))) ?v_399) ?v_384) ?v_390) ?v_391) ?v_392) ?v_393) (and (and (and (and (and (and (and (= ?v_379 2) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_386) ?v_382) ?v_388) ?v_383) x_411) ?v_281) x_419) ?v_353) (and (and (and (and (and (and (and ?v_381 x_356) ?v_382) x_325) ?v_383) ?v_285) x_412) ?v_384)) (and (and (and (and (and (and ?v_385 ?v_386) x_357) x_411) x_412) ?v_364) x_420)) (and (and (and (and (and (and (and (and ?v_387 x_356) x_357) ?v_388) x_326) ?v_285) ?v_281) ?v_364) ?v_353))) ?v_398) ?v_389) ?v_390) ?v_391) ?v_392) ?v_393)) (and (and (and (and (and (and (and (= ?v_379 3) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_396) ?v_394) ?v_397) ?v_395) x_413) ?v_293) x_421) ?v_356) (and (and (and (and (and (and (and ?v_381 x_358) ?v_394) x_327) ?v_395) ?v_295) x_414) ?v_391)) (and (and (and (and (and (and ?v_385 ?v_396) x_359) x_413) x_414) ?v_366) x_422)) (and (and (and (and (and (and (and (and ?v_387 x_358) x_359) ?v_397) x_328) ?v_295) ?v_293) ?v_366) ?v_356))) ?v_398) ?v_389) ?v_399) ?v_384) ?v_392) ?v_393)) (and (and (and (and (and (and (and (= ?v_379 4) (or (or (or (and (and (and (and (and (and (and (and ?v_380 ?v_402) ?v_400) ?v_403) ?v_401) x_415) ?v_299) x_423) ?v_358) (and (and (and (and (and (and (and ?v_381 x_360) ?v_400) x_329) ?v_401) ?v_301) x_416) ?v_393)) (and (and (and (and (and (and ?v_385 ?v_402) x_361) x_415) x_416) ?v_368) x_424)) (and (and (and (and (and (and (and (and ?v_387 x_360) x_361) ?v_403) x_330) ?v_301) ?v_299) ?v_368) ?v_358))) ?v_398) ?v_389) ?v_399) ?v_384) ?v_390) ?v_391))) ?v_450) ?v_405) ?v_449) ?v_474) ?v_473) (and (and (and (and (and (and (and (and (and (= ?v_404 1) (or (or (or (and (and (and (and (= ?v_448 0) (not ?v_471)) (= (- x_376 x_377) 0)) ?v_405) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 1) ?v_462) ?v_451) ?v_463) ?v_452) (ite ?v_432 (= ?v_99 1) ?v_406)) (ite ?v_433 (= ?v_100 1) ?v_408)) (ite ?v_434 (= ?v_101 1) ?v_409)) (ite ?v_435 (= ?v_102 1) ?v_410)) (ite ?v_436 (= ?v_103 1) ?v_411)) (ite ?v_437 (= ?v_104 1) ?v_412)) (ite ?v_438 (= ?v_105 1) ?v_413)) (ite ?v_439 (= ?v_106 1) ?v_414)) (ite ?v_440 (= ?v_107 1) ?v_415)) (ite ?v_441 (= ?v_108 1) ?v_416)) (ite ?v_442 (= ?v_109 1) ?v_417)) (ite ?v_443 (= ?v_110 1) ?v_418)) x_398) ?v_351) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424) ?v_277) ?v_275) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 2) ?v_465) ?v_454) ?v_466) ?v_455) (ite ?v_432 (= ?v_99 2) ?v_406)) (ite ?v_433 (= ?v_100 2) ?v_408)) (ite ?v_434 (= ?v_101 2) ?v_409)) (ite ?v_435 (= ?v_102 2) ?v_410)) (ite ?v_436 (= ?v_103 2) ?v_411)) (ite ?v_437 (= ?v_104 2) ?v_412)) (ite ?v_438 (= ?v_105 2) ?v_413)) (ite ?v_439 (= ?v_106 2) ?v_414)) (ite ?v_440 (= ?v_107 2) ?v_415)) (ite ?v_441 (= ?v_108 2) ?v_416)) (ite ?v_442 (= ?v_109 2) ?v_417)) (ite ?v_443 (= ?v_110 2) ?v_418)) ?v_444) ?v_445) x_400) ?v_354) ?v_421) ?v_422) ?v_423) ?v_424) ?v_446) ?v_447) ?v_287) ?v_282) ?v_427) ?v_428) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 3) ?v_467) ?v_457) ?v_468) ?v_458) (ite ?v_432 (= ?v_99 3) ?v_406)) (ite ?v_433 (= ?v_100 3) ?v_408)) (ite ?v_434 (= ?v_101 3) ?v_409)) (ite ?v_435 (= ?v_102 3) ?v_410)) (ite ?v_436 (= ?v_103 3) ?v_411)) (ite ?v_437 (= ?v_104 3) ?v_412)) (ite ?v_438 (= ?v_105 3) ?v_413)) (ite ?v_439 (= ?v_106 3) ?v_414)) (ite ?v_440 (= ?v_107 3) ?v_415)) (ite ?v_441 (= ?v_108 3) ?v_416)) (ite ?v_442 (= ?v_109 3) ?v_417)) (ite ?v_443 (= ?v_110 3) ?v_418)) ?v_444) ?v_445) ?v_419) ?v_420) x_402) ?v_357) ?v_423) ?v_424) ?v_446) ?v_447) ?v_425) ?v_426) ?v_296) ?v_294) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_431 4) ?v_469) ?v_459) ?v_470) ?v_460) (ite ?v_432 (= ?v_99 4) ?v_406)) (ite ?v_433 (= ?v_100 4) ?v_408)) (ite ?v_434 (= ?v_101 4) ?v_409)) (ite ?v_435 (= ?v_102 4) ?v_410)) (ite ?v_436 (= ?v_103 4) ?v_411)) (ite ?v_437 (= ?v_104 4) ?v_412)) (ite ?v_438 (= ?v_105 4) ?v_413)) (ite ?v_439 (= ?v_106 4) ?v_414)) (ite ?v_440 (= ?v_107 4) ?v_415)) (ite ?v_441 (= ?v_108 4) ?v_416)) (ite ?v_442 (= ?v_109 4) ?v_417)) (ite ?v_443 (= ?v_110 4) ?v_418)) ?v_444) ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) x_404) ?v_359) ?v_446) ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) ?v_302) ?v_300))) (and (and (and (and (= ?v_448 1) ?v_449) ?v_405) ?v_450) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 1) x_362) ?v_451) x_343) ?v_452) (= ?v_456 1)) ?v_362) x_399) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424) x_378) ?v_275) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 2) x_364) ?v_454) x_345) ?v_455) (= ?v_456 2)) ?v_444) ?v_445) ?v_365) x_401) ?v_421) ?v_422) ?v_423) ?v_424) ?v_446) ?v_447) x_380) ?v_282) ?v_427) ?v_428) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 3) x_366) ?v_457) x_347) ?v_458) (= ?v_456 3)) ?v_444) ?v_445) ?v_419) ?v_420) ?v_367) x_403) ?v_423) ?v_424) ?v_446) ?v_447) ?v_425) ?v_426) x_382) ?v_294) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_453 4) x_368) ?v_459) x_349) ?v_460) (= ?v_456 4)) ?v_444) ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) ?v_369) x_405) ?v_446) ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) x_384) ?v_300)))) (and (and (and (and (= ?v_448 2) (= ?v_461 1)) ?v_449) ?v_450) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 1) ?v_462) x_363) ?v_463) x_344) ?v_362) ?v_351) ?v_419) ?v_420) ?v_421) ?v_422) ?v_423) ?v_424) ?v_277) x_379) ?v_425) ?v_426) ?v_427) ?v_428) ?v_429) ?v_430) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 2) ?v_465) x_365) ?v_466) x_346) ?v_444) ?v_445) ?v_365) ?v_354) ?v_421) ?v_422) ?v_423) ?v_424) ?v_446) ?v_447) ?v_287) x_381) ?v_427) ?v_428) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 3) ?v_467) x_367) ?v_468) x_348) ?v_444) ?v_445) ?v_419) ?v_420) ?v_367) ?v_357) ?v_423) ?v_424) ?v_446) ?v_447) ?v_425) ?v_426) ?v_296) x_383) ?v_429) ?v_430)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_464 4) ?v_469) x_369) ?v_470) x_350) ?v_444) ?v_445) ?v_419) ?v_420) ?v_421) ?v_422) ?v_369) ?v_359) ?v_446) ?v_447) ?v_425) ?v_426) ?v_427) ?v_428) ?v_302) x_385)))) (and (and (and (and (and (and (and (= ?v_448 3) (= (- x_352 x_377) 0)) ?v_471) ?v_472) (= ?v_98 0)) ?v_473) ?v_449) ?v_474))) ?v_398) ?v_399) ?v_390) ?v_392) ?v_389) ?v_384) ?v_391) ?v_393))) (or (and (and (and (and (and (and (= ?v_505 0) (or (or (or (and (and (and (and (and (and (and (= ?v_480 1) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_478) ?v_476) ?v_479) ?v_477) x_354) ?v_375) x_362) ?v_451) (and (and (and (and (and (and (and ?v_482 x_299) ?v_476) x_268) ?v_477) ?v_377) x_355) ?v_490)) (and (and (and (and (and (and ?v_486 ?v_478) x_300) x_354) x_355) ?v_462) x_363)) (and (and (and (and (and (and (and (and ?v_488 x_299) x_300) ?v_479) x_269) ?v_377) ?v_375) ?v_462) ?v_451))) ?v_500) ?v_485) ?v_491) ?v_492) ?v_493) ?v_494) (and (and (and (and (and (and (and (= ?v_480 2) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_487) ?v_483) ?v_489) ?v_484) x_356) ?v_382) x_364) ?v_454) (and (and (and (and (and (and (and ?v_482 x_301) ?v_483) x_270) ?v_484) ?v_386) x_357) ?v_485)) (and (and (and (and (and (and ?v_486 ?v_487) x_302) x_356) x_357) ?v_465) x_365)) (and (and (and (and (and (and (and (and ?v_488 x_301) x_302) ?v_489) x_271) ?v_386) ?v_382) ?v_465) ?v_454))) ?v_499) ?v_490) ?v_491) ?v_492) ?v_493) ?v_494)) (and (and (and (and (and (and (and (= ?v_480 3) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_497) ?v_495) ?v_498) ?v_496) x_358) ?v_394) x_366) ?v_457) (and (and (and (and (and (and (and ?v_482 x_303) ?v_495) x_272) ?v_496) ?v_396) x_359) ?v_492)) (and (and (and (and (and (and ?v_486 ?v_497) x_304) x_358) x_359) ?v_467) x_367)) (and (and (and (and (and (and (and (and ?v_488 x_303) x_304) ?v_498) x_273) ?v_396) ?v_394) ?v_467) ?v_457))) ?v_499) ?v_490) ?v_500) ?v_485) ?v_493) ?v_494)) (and (and (and (and (and (and (and (= ?v_480 4) (or (or (or (and (and (and (and (and (and (and (and ?v_481 ?v_503) ?v_501) ?v_504) ?v_502) x_360) ?v_400) x_368) ?v_459) (and (and (and (and (and (and (and ?v_482 x_305) ?v_501) x_274) ?v_502) ?v_402) x_361) ?v_494)) (and (and (and (and (and (and ?v_486 ?v_503) x_306) x_360) x_361) ?v_469) x_369)) (and (and (and (and (and (and (and (and ?v_488 x_305) x_306) ?v_504) x_275) ?v_402) ?v_400) ?v_469) ?v_459))) ?v_499) ?v_490) ?v_500) ?v_485) ?v_491) ?v_492))) ?v_551) ?v_506) ?v_550) ?v_575) ?v_574) (and (and (and (and (and (and (and (and (and (= ?v_505 1) (or (or (or (and (and (and (and (= ?v_549 0) (not ?v_572)) (= (- x_321 x_322) 0)) ?v_506) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 1) ?v_563) ?v_552) ?v_564) ?v_553) (ite ?v_533 (= ?v_85 1) ?v_507)) (ite ?v_534 (= ?v_86 1) ?v_509)) (ite ?v_535 (= ?v_87 1) ?v_510)) (ite ?v_536 (= ?v_88 1) ?v_511)) (ite ?v_537 (= ?v_89 1) ?v_512)) (ite ?v_538 (= ?v_90 1) ?v_513)) (ite ?v_539 (= ?v_91 1) ?v_514)) (ite ?v_540 (= ?v_92 1) ?v_515)) (ite ?v_541 (= ?v_93 1) ?v_516)) (ite ?v_542 (= ?v_94 1) ?v_517)) (ite ?v_543 (= ?v_95 1) ?v_518)) (ite ?v_544 (= ?v_96 1) ?v_519)) x_343) ?v_452) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525) ?v_378) ?v_376) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 2) ?v_566) ?v_555) ?v_567) ?v_556) (ite ?v_533 (= ?v_85 2) ?v_507)) (ite ?v_534 (= ?v_86 2) ?v_509)) (ite ?v_535 (= ?v_87 2) ?v_510)) (ite ?v_536 (= ?v_88 2) ?v_511)) (ite ?v_537 (= ?v_89 2) ?v_512)) (ite ?v_538 (= ?v_90 2) ?v_513)) (ite ?v_539 (= ?v_91 2) ?v_514)) (ite ?v_540 (= ?v_92 2) ?v_515)) (ite ?v_541 (= ?v_93 2) ?v_516)) (ite ?v_542 (= ?v_94 2) ?v_517)) (ite ?v_543 (= ?v_95 2) ?v_518)) (ite ?v_544 (= ?v_96 2) ?v_519)) ?v_545) ?v_546) x_345) ?v_455) ?v_522) ?v_523) ?v_524) ?v_525) ?v_547) ?v_548) ?v_388) ?v_383) ?v_528) ?v_529) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 3) ?v_568) ?v_558) ?v_569) ?v_559) (ite ?v_533 (= ?v_85 3) ?v_507)) (ite ?v_534 (= ?v_86 3) ?v_509)) (ite ?v_535 (= ?v_87 3) ?v_510)) (ite ?v_536 (= ?v_88 3) ?v_511)) (ite ?v_537 (= ?v_89 3) ?v_512)) (ite ?v_538 (= ?v_90 3) ?v_513)) (ite ?v_539 (= ?v_91 3) ?v_514)) (ite ?v_540 (= ?v_92 3) ?v_515)) (ite ?v_541 (= ?v_93 3) ?v_516)) (ite ?v_542 (= ?v_94 3) ?v_517)) (ite ?v_543 (= ?v_95 3) ?v_518)) (ite ?v_544 (= ?v_96 3) ?v_519)) ?v_545) ?v_546) ?v_520) ?v_521) x_347) ?v_458) ?v_524) ?v_525) ?v_547) ?v_548) ?v_526) ?v_527) ?v_397) ?v_395) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_532 4) ?v_570) ?v_560) ?v_571) ?v_561) (ite ?v_533 (= ?v_85 4) ?v_507)) (ite ?v_534 (= ?v_86 4) ?v_509)) (ite ?v_535 (= ?v_87 4) ?v_510)) (ite ?v_536 (= ?v_88 4) ?v_511)) (ite ?v_537 (= ?v_89 4) ?v_512)) (ite ?v_538 (= ?v_90 4) ?v_513)) (ite ?v_539 (= ?v_91 4) ?v_514)) (ite ?v_540 (= ?v_92 4) ?v_515)) (ite ?v_541 (= ?v_93 4) ?v_516)) (ite ?v_542 (= ?v_94 4) ?v_517)) (ite ?v_543 (= ?v_95 4) ?v_518)) (ite ?v_544 (= ?v_96 4) ?v_519)) ?v_545) ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) x_349) ?v_460) ?v_547) ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) ?v_403) ?v_401))) (and (and (and (and (= ?v_549 1) ?v_550) ?v_506) ?v_551) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 1) x_307) ?v_552) x_288) ?v_553) (= ?v_557 1)) ?v_463) x_344) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525) x_323) ?v_376) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 2) x_309) ?v_555) x_290) ?v_556) (= ?v_557 2)) ?v_545) ?v_546) ?v_466) x_346) ?v_522) ?v_523) ?v_524) ?v_525) ?v_547) ?v_548) x_325) ?v_383) ?v_528) ?v_529) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 3) x_311) ?v_558) x_292) ?v_559) (= ?v_557 3)) ?v_545) ?v_546) ?v_520) ?v_521) ?v_468) x_348) ?v_524) ?v_525) ?v_547) ?v_548) ?v_526) ?v_527) x_327) ?v_395) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_554 4) x_313) ?v_560) x_294) ?v_561) (= ?v_557 4)) ?v_545) ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) ?v_470) x_350) ?v_547) ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) x_329) ?v_401)))) (and (and (and (and (= ?v_549 2) (= ?v_562 1)) ?v_550) ?v_551) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 1) ?v_563) x_308) ?v_564) x_289) ?v_463) ?v_452) ?v_520) ?v_521) ?v_522) ?v_523) ?v_524) ?v_525) ?v_378) x_324) ?v_526) ?v_527) ?v_528) ?v_529) ?v_530) ?v_531) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 2) ?v_566) x_310) ?v_567) x_291) ?v_545) ?v_546) ?v_466) ?v_455) ?v_522) ?v_523) ?v_524) ?v_525) ?v_547) ?v_548) ?v_388) x_326) ?v_528) ?v_529) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 3) ?v_568) x_312) ?v_569) x_293) ?v_545) ?v_546) ?v_520) ?v_521) ?v_468) ?v_458) ?v_524) ?v_525) ?v_547) ?v_548) ?v_526) ?v_527) ?v_397) x_328) ?v_530) ?v_531)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_565 4) ?v_570) x_314) ?v_571) x_295) ?v_545) ?v_546) ?v_520) ?v_521) ?v_522) ?v_523) ?v_470) ?v_460) ?v_547) ?v_548) ?v_526) ?v_527) ?v_528) ?v_529) ?v_403) x_330)))) (and (and (and (and (and (and (and (= ?v_549 3) (= (- x_297 x_322) 0)) ?v_572) ?v_573) (= ?v_84 0)) ?v_574) ?v_550) ?v_575))) ?v_499) ?v_500) ?v_491) ?v_493) ?v_490) ?v_485) ?v_492) ?v_494))) (or (and (and (and (and (and (and (= ?v_606 0) (or (or (or (and (and (and (and (and (and (and (= ?v_581 1) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_579) ?v_577) ?v_580) ?v_578) x_299) ?v_476) x_307) ?v_552) (and (and (and (and (and (and (and ?v_583 x_244) ?v_577) x_213) ?v_578) ?v_478) x_300) ?v_591)) (and (and (and (and (and (and ?v_587 ?v_579) x_245) x_299) x_300) ?v_563) x_308)) (and (and (and (and (and (and (and (and ?v_589 x_244) x_245) ?v_580) x_214) ?v_478) ?v_476) ?v_563) ?v_552))) ?v_601) ?v_586) ?v_592) ?v_593) ?v_594) ?v_595) (and (and (and (and (and (and (and (= ?v_581 2) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_588) ?v_584) ?v_590) ?v_585) x_301) ?v_483) x_309) ?v_555) (and (and (and (and (and (and (and ?v_583 x_246) ?v_584) x_215) ?v_585) ?v_487) x_302) ?v_586)) (and (and (and (and (and (and ?v_587 ?v_588) x_247) x_301) x_302) ?v_566) x_310)) (and (and (and (and (and (and (and (and ?v_589 x_246) x_247) ?v_590) x_216) ?v_487) ?v_483) ?v_566) ?v_555))) ?v_600) ?v_591) ?v_592) ?v_593) ?v_594) ?v_595)) (and (and (and (and (and (and (and (= ?v_581 3) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_598) ?v_596) ?v_599) ?v_597) x_303) ?v_495) x_311) ?v_558) (and (and (and (and (and (and (and ?v_583 x_248) ?v_596) x_217) ?v_597) ?v_497) x_304) ?v_593)) (and (and (and (and (and (and ?v_587 ?v_598) x_249) x_303) x_304) ?v_568) x_312)) (and (and (and (and (and (and (and (and ?v_589 x_248) x_249) ?v_599) x_218) ?v_497) ?v_495) ?v_568) ?v_558))) ?v_600) ?v_591) ?v_601) ?v_586) ?v_594) ?v_595)) (and (and (and (and (and (and (and (= ?v_581 4) (or (or (or (and (and (and (and (and (and (and (and ?v_582 ?v_604) ?v_602) ?v_605) ?v_603) x_305) ?v_501) x_313) ?v_560) (and (and (and (and (and (and (and ?v_583 x_250) ?v_602) x_219) ?v_603) ?v_503) x_306) ?v_595)) (and (and (and (and (and (and ?v_587 ?v_604) x_251) x_305) x_306) ?v_570) x_314)) (and (and (and (and (and (and (and (and ?v_589 x_250) x_251) ?v_605) x_220) ?v_503) ?v_501) ?v_570) ?v_560))) ?v_600) ?v_591) ?v_601) ?v_586) ?v_592) ?v_593))) ?v_652) ?v_607) ?v_651) ?v_676) ?v_675) (and (and (and (and (and (and (and (and (and (= ?v_606 1) (or (or (or (and (and (and (and (= ?v_650 0) (not ?v_673)) (= (- x_266 x_267) 0)) ?v_607) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 1) ?v_664) ?v_653) ?v_665) ?v_654) (ite ?v_634 (= ?v_71 1) ?v_608)) (ite ?v_635 (= ?v_72 1) ?v_610)) (ite ?v_636 (= ?v_73 1) ?v_611)) (ite ?v_637 (= ?v_74 1) ?v_612)) (ite ?v_638 (= ?v_75 1) ?v_613)) (ite ?v_639 (= ?v_76 1) ?v_614)) (ite ?v_640 (= ?v_77 1) ?v_615)) (ite ?v_641 (= ?v_78 1) ?v_616)) (ite ?v_642 (= ?v_79 1) ?v_617)) (ite ?v_643 (= ?v_80 1) ?v_618)) (ite ?v_644 (= ?v_81 1) ?v_619)) (ite ?v_645 (= ?v_82 1) ?v_620)) x_288) ?v_553) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626) ?v_479) ?v_477) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 2) ?v_667) ?v_656) ?v_668) ?v_657) (ite ?v_634 (= ?v_71 2) ?v_608)) (ite ?v_635 (= ?v_72 2) ?v_610)) (ite ?v_636 (= ?v_73 2) ?v_611)) (ite ?v_637 (= ?v_74 2) ?v_612)) (ite ?v_638 (= ?v_75 2) ?v_613)) (ite ?v_639 (= ?v_76 2) ?v_614)) (ite ?v_640 (= ?v_77 2) ?v_615)) (ite ?v_641 (= ?v_78 2) ?v_616)) (ite ?v_642 (= ?v_79 2) ?v_617)) (ite ?v_643 (= ?v_80 2) ?v_618)) (ite ?v_644 (= ?v_81 2) ?v_619)) (ite ?v_645 (= ?v_82 2) ?v_620)) ?v_646) ?v_647) x_290) ?v_556) ?v_623) ?v_624) ?v_625) ?v_626) ?v_648) ?v_649) ?v_489) ?v_484) ?v_629) ?v_630) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 3) ?v_669) ?v_659) ?v_670) ?v_660) (ite ?v_634 (= ?v_71 3) ?v_608)) (ite ?v_635 (= ?v_72 3) ?v_610)) (ite ?v_636 (= ?v_73 3) ?v_611)) (ite ?v_637 (= ?v_74 3) ?v_612)) (ite ?v_638 (= ?v_75 3) ?v_613)) (ite ?v_639 (= ?v_76 3) ?v_614)) (ite ?v_640 (= ?v_77 3) ?v_615)) (ite ?v_641 (= ?v_78 3) ?v_616)) (ite ?v_642 (= ?v_79 3) ?v_617)) (ite ?v_643 (= ?v_80 3) ?v_618)) (ite ?v_644 (= ?v_81 3) ?v_619)) (ite ?v_645 (= ?v_82 3) ?v_620)) ?v_646) ?v_647) ?v_621) ?v_622) x_292) ?v_559) ?v_625) ?v_626) ?v_648) ?v_649) ?v_627) ?v_628) ?v_498) ?v_496) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_633 4) ?v_671) ?v_661) ?v_672) ?v_662) (ite ?v_634 (= ?v_71 4) ?v_608)) (ite ?v_635 (= ?v_72 4) ?v_610)) (ite ?v_636 (= ?v_73 4) ?v_611)) (ite ?v_637 (= ?v_74 4) ?v_612)) (ite ?v_638 (= ?v_75 4) ?v_613)) (ite ?v_639 (= ?v_76 4) ?v_614)) (ite ?v_640 (= ?v_77 4) ?v_615)) (ite ?v_641 (= ?v_78 4) ?v_616)) (ite ?v_642 (= ?v_79 4) ?v_617)) (ite ?v_643 (= ?v_80 4) ?v_618)) (ite ?v_644 (= ?v_81 4) ?v_619)) (ite ?v_645 (= ?v_82 4) ?v_620)) ?v_646) ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) x_294) ?v_561) ?v_648) ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) ?v_504) ?v_502))) (and (and (and (and (= ?v_650 1) ?v_651) ?v_607) ?v_652) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 1) x_252) ?v_653) x_233) ?v_654) (= ?v_658 1)) ?v_564) x_289) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626) x_268) ?v_477) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 2) x_254) ?v_656) x_235) ?v_657) (= ?v_658 2)) ?v_646) ?v_647) ?v_567) x_291) ?v_623) ?v_624) ?v_625) ?v_626) ?v_648) ?v_649) x_270) ?v_484) ?v_629) ?v_630) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 3) x_256) ?v_659) x_237) ?v_660) (= ?v_658 3)) ?v_646) ?v_647) ?v_621) ?v_622) ?v_569) x_293) ?v_625) ?v_626) ?v_648) ?v_649) ?v_627) ?v_628) x_272) ?v_496) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_655 4) x_258) ?v_661) x_239) ?v_662) (= ?v_658 4)) ?v_646) ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) ?v_571) x_295) ?v_648) ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) x_274) ?v_502)))) (and (and (and (and (= ?v_650 2) (= ?v_663 1)) ?v_651) ?v_652) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 1) ?v_664) x_253) ?v_665) x_234) ?v_564) ?v_553) ?v_621) ?v_622) ?v_623) ?v_624) ?v_625) ?v_626) ?v_479) x_269) ?v_627) ?v_628) ?v_629) ?v_630) ?v_631) ?v_632) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 2) ?v_667) x_255) ?v_668) x_236) ?v_646) ?v_647) ?v_567) ?v_556) ?v_623) ?v_624) ?v_625) ?v_626) ?v_648) ?v_649) ?v_489) x_271) ?v_629) ?v_630) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 3) ?v_669) x_257) ?v_670) x_238) ?v_646) ?v_647) ?v_621) ?v_622) ?v_569) ?v_559) ?v_625) ?v_626) ?v_648) ?v_649) ?v_627) ?v_628) ?v_498) x_273) ?v_631) ?v_632)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_666 4) ?v_671) x_259) ?v_672) x_240) ?v_646) ?v_647) ?v_621) ?v_622) ?v_623) ?v_624) ?v_571) ?v_561) ?v_648) ?v_649) ?v_627) ?v_628) ?v_629) ?v_630) ?v_504) x_275)))) (and (and (and (and (and (and (and (= ?v_650 3) (= (- x_242 x_267) 0)) ?v_673) ?v_674) (= ?v_70 0)) ?v_675) ?v_651) ?v_676))) ?v_600) ?v_601) ?v_592) ?v_594) ?v_591) ?v_586) ?v_593) ?v_595))) (or (and (and (and (and (and (and (= ?v_707 0) (or (or (or (and (and (and (and (and (and (and (= ?v_682 1) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_680) ?v_678) ?v_681) ?v_679) x_244) ?v_577) x_252) ?v_653) (and (and (and (and (and (and (and ?v_684 x_189) ?v_678) x_158) ?v_679) ?v_579) x_245) ?v_692)) (and (and (and (and (and (and ?v_688 ?v_680) x_190) x_244) x_245) ?v_664) x_253)) (and (and (and (and (and (and (and (and ?v_690 x_189) x_190) ?v_681) x_159) ?v_579) ?v_577) ?v_664) ?v_653))) ?v_702) ?v_687) ?v_693) ?v_694) ?v_695) ?v_696) (and (and (and (and (and (and (and (= ?v_682 2) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_689) ?v_685) ?v_691) ?v_686) x_246) ?v_584) x_254) ?v_656) (and (and (and (and (and (and (and ?v_684 x_191) ?v_685) x_160) ?v_686) ?v_588) x_247) ?v_687)) (and (and (and (and (and (and ?v_688 ?v_689) x_192) x_246) x_247) ?v_667) x_255)) (and (and (and (and (and (and (and (and ?v_690 x_191) x_192) ?v_691) x_161) ?v_588) ?v_584) ?v_667) ?v_656))) ?v_701) ?v_692) ?v_693) ?v_694) ?v_695) ?v_696)) (and (and (and (and (and (and (and (= ?v_682 3) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_699) ?v_697) ?v_700) ?v_698) x_248) ?v_596) x_256) ?v_659) (and (and (and (and (and (and (and ?v_684 x_193) ?v_697) x_162) ?v_698) ?v_598) x_249) ?v_694)) (and (and (and (and (and (and ?v_688 ?v_699) x_194) x_248) x_249) ?v_669) x_257)) (and (and (and (and (and (and (and (and ?v_690 x_193) x_194) ?v_700) x_163) ?v_598) ?v_596) ?v_669) ?v_659))) ?v_701) ?v_692) ?v_702) ?v_687) ?v_695) ?v_696)) (and (and (and (and (and (and (and (= ?v_682 4) (or (or (or (and (and (and (and (and (and (and (and ?v_683 ?v_705) ?v_703) ?v_706) ?v_704) x_250) ?v_602) x_258) ?v_661) (and (and (and (and (and (and (and ?v_684 x_195) ?v_703) x_164) ?v_704) ?v_604) x_251) ?v_696)) (and (and (and (and (and (and ?v_688 ?v_705) x_196) x_250) x_251) ?v_671) x_259)) (and (and (and (and (and (and (and (and ?v_690 x_195) x_196) ?v_706) x_165) ?v_604) ?v_602) ?v_671) ?v_661))) ?v_701) ?v_692) ?v_702) ?v_687) ?v_693) ?v_694))) ?v_753) ?v_708) ?v_752) ?v_777) ?v_776) (and (and (and (and (and (and (and (and (and (= ?v_707 1) (or (or (or (and (and (and (and (= ?v_751 0) (not ?v_774)) (= (- x_211 x_212) 0)) ?v_708) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 1) ?v_765) ?v_754) ?v_766) ?v_755) (ite ?v_735 (= ?v_57 1) ?v_709)) (ite ?v_736 (= ?v_58 1) ?v_711)) (ite ?v_737 (= ?v_59 1) ?v_712)) (ite ?v_738 (= ?v_60 1) ?v_713)) (ite ?v_739 (= ?v_61 1) ?v_714)) (ite ?v_740 (= ?v_62 1) ?v_715)) (ite ?v_741 (= ?v_63 1) ?v_716)) (ite ?v_742 (= ?v_64 1) ?v_717)) (ite ?v_743 (= ?v_65 1) ?v_718)) (ite ?v_744 (= ?v_66 1) ?v_719)) (ite ?v_745 (= ?v_67 1) ?v_720)) (ite ?v_746 (= ?v_68 1) ?v_721)) x_233) ?v_654) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727) ?v_580) ?v_578) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 2) ?v_768) ?v_757) ?v_769) ?v_758) (ite ?v_735 (= ?v_57 2) ?v_709)) (ite ?v_736 (= ?v_58 2) ?v_711)) (ite ?v_737 (= ?v_59 2) ?v_712)) (ite ?v_738 (= ?v_60 2) ?v_713)) (ite ?v_739 (= ?v_61 2) ?v_714)) (ite ?v_740 (= ?v_62 2) ?v_715)) (ite ?v_741 (= ?v_63 2) ?v_716)) (ite ?v_742 (= ?v_64 2) ?v_717)) (ite ?v_743 (= ?v_65 2) ?v_718)) (ite ?v_744 (= ?v_66 2) ?v_719)) (ite ?v_745 (= ?v_67 2) ?v_720)) (ite ?v_746 (= ?v_68 2) ?v_721)) ?v_747) ?v_748) x_235) ?v_657) ?v_724) ?v_725) ?v_726) ?v_727) ?v_749) ?v_750) ?v_590) ?v_585) ?v_730) ?v_731) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 3) ?v_770) ?v_760) ?v_771) ?v_761) (ite ?v_735 (= ?v_57 3) ?v_709)) (ite ?v_736 (= ?v_58 3) ?v_711)) (ite ?v_737 (= ?v_59 3) ?v_712)) (ite ?v_738 (= ?v_60 3) ?v_713)) (ite ?v_739 (= ?v_61 3) ?v_714)) (ite ?v_740 (= ?v_62 3) ?v_715)) (ite ?v_741 (= ?v_63 3) ?v_716)) (ite ?v_742 (= ?v_64 3) ?v_717)) (ite ?v_743 (= ?v_65 3) ?v_718)) (ite ?v_744 (= ?v_66 3) ?v_719)) (ite ?v_745 (= ?v_67 3) ?v_720)) (ite ?v_746 (= ?v_68 3) ?v_721)) ?v_747) ?v_748) ?v_722) ?v_723) x_237) ?v_660) ?v_726) ?v_727) ?v_749) ?v_750) ?v_728) ?v_729) ?v_599) ?v_597) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_734 4) ?v_772) ?v_762) ?v_773) ?v_763) (ite ?v_735 (= ?v_57 4) ?v_709)) (ite ?v_736 (= ?v_58 4) ?v_711)) (ite ?v_737 (= ?v_59 4) ?v_712)) (ite ?v_738 (= ?v_60 4) ?v_713)) (ite ?v_739 (= ?v_61 4) ?v_714)) (ite ?v_740 (= ?v_62 4) ?v_715)) (ite ?v_741 (= ?v_63 4) ?v_716)) (ite ?v_742 (= ?v_64 4) ?v_717)) (ite ?v_743 (= ?v_65 4) ?v_718)) (ite ?v_744 (= ?v_66 4) ?v_719)) (ite ?v_745 (= ?v_67 4) ?v_720)) (ite ?v_746 (= ?v_68 4) ?v_721)) ?v_747) ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) x_239) ?v_662) ?v_749) ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) ?v_605) ?v_603))) (and (and (and (and (= ?v_751 1) ?v_752) ?v_708) ?v_753) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 1) x_197) ?v_754) x_178) ?v_755) (= ?v_759 1)) ?v_665) x_234) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727) x_213) ?v_578) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 2) x_199) ?v_757) x_180) ?v_758) (= ?v_759 2)) ?v_747) ?v_748) ?v_668) x_236) ?v_724) ?v_725) ?v_726) ?v_727) ?v_749) ?v_750) x_215) ?v_585) ?v_730) ?v_731) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 3) x_201) ?v_760) x_182) ?v_761) (= ?v_759 3)) ?v_747) ?v_748) ?v_722) ?v_723) ?v_670) x_238) ?v_726) ?v_727) ?v_749) ?v_750) ?v_728) ?v_729) x_217) ?v_597) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_756 4) x_203) ?v_762) x_184) ?v_763) (= ?v_759 4)) ?v_747) ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) ?v_672) x_240) ?v_749) ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) x_219) ?v_603)))) (and (and (and (and (= ?v_751 2) (= ?v_764 1)) ?v_752) ?v_753) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 1) ?v_765) x_198) ?v_766) x_179) ?v_665) ?v_654) ?v_722) ?v_723) ?v_724) ?v_725) ?v_726) ?v_727) ?v_580) x_214) ?v_728) ?v_729) ?v_730) ?v_731) ?v_732) ?v_733) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 2) ?v_768) x_200) ?v_769) x_181) ?v_747) ?v_748) ?v_668) ?v_657) ?v_724) ?v_725) ?v_726) ?v_727) ?v_749) ?v_750) ?v_590) x_216) ?v_730) ?v_731) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 3) ?v_770) x_202) ?v_771) x_183) ?v_747) ?v_748) ?v_722) ?v_723) ?v_670) ?v_660) ?v_726) ?v_727) ?v_749) ?v_750) ?v_728) ?v_729) ?v_599) x_218) ?v_732) ?v_733)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_767 4) ?v_772) x_204) ?v_773) x_185) ?v_747) ?v_748) ?v_722) ?v_723) ?v_724) ?v_725) ?v_672) ?v_662) ?v_749) ?v_750) ?v_728) ?v_729) ?v_730) ?v_731) ?v_605) x_220)))) (and (and (and (and (and (and (and (= ?v_751 3) (= (- x_187 x_212) 0)) ?v_774) ?v_775) (= ?v_56 0)) ?v_776) ?v_752) ?v_777))) ?v_701) ?v_702) ?v_693) ?v_695) ?v_692) ?v_687) ?v_694) ?v_696))) (or (and (and (and (and (and (and (= ?v_808 0) (or (or (or (and (and (and (and (and (and (and (= ?v_783 1) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_781) ?v_779) ?v_782) ?v_780) x_189) ?v_678) x_197) ?v_754) (and (and (and (and (and (and (and ?v_785 x_134) ?v_779) x_103) ?v_780) ?v_680) x_190) ?v_793)) (and (and (and (and (and (and ?v_789 ?v_781) x_135) x_189) x_190) ?v_765) x_198)) (and (and (and (and (and (and (and (and ?v_791 x_134) x_135) ?v_782) x_104) ?v_680) ?v_678) ?v_765) ?v_754))) ?v_803) ?v_788) ?v_794) ?v_795) ?v_796) ?v_797) (and (and (and (and (and (and (and (= ?v_783 2) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_790) ?v_786) ?v_792) ?v_787) x_191) ?v_685) x_199) ?v_757) (and (and (and (and (and (and (and ?v_785 x_136) ?v_786) x_105) ?v_787) ?v_689) x_192) ?v_788)) (and (and (and (and (and (and ?v_789 ?v_790) x_137) x_191) x_192) ?v_768) x_200)) (and (and (and (and (and (and (and (and ?v_791 x_136) x_137) ?v_792) x_106) ?v_689) ?v_685) ?v_768) ?v_757))) ?v_802) ?v_793) ?v_794) ?v_795) ?v_796) ?v_797)) (and (and (and (and (and (and (and (= ?v_783 3) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_800) ?v_798) ?v_801) ?v_799) x_193) ?v_697) x_201) ?v_760) (and (and (and (and (and (and (and ?v_785 x_138) ?v_798) x_107) ?v_799) ?v_699) x_194) ?v_795)) (and (and (and (and (and (and ?v_789 ?v_800) x_139) x_193) x_194) ?v_770) x_202)) (and (and (and (and (and (and (and (and ?v_791 x_138) x_139) ?v_801) x_108) ?v_699) ?v_697) ?v_770) ?v_760))) ?v_802) ?v_793) ?v_803) ?v_788) ?v_796) ?v_797)) (and (and (and (and (and (and (and (= ?v_783 4) (or (or (or (and (and (and (and (and (and (and (and ?v_784 ?v_806) ?v_804) ?v_807) ?v_805) x_195) ?v_703) x_203) ?v_762) (and (and (and (and (and (and (and ?v_785 x_140) ?v_804) x_109) ?v_805) ?v_705) x_196) ?v_797)) (and (and (and (and (and (and ?v_789 ?v_806) x_141) x_195) x_196) ?v_772) x_204)) (and (and (and (and (and (and (and (and ?v_791 x_140) x_141) ?v_807) x_110) ?v_705) ?v_703) ?v_772) ?v_762))) ?v_802) ?v_793) ?v_803) ?v_788) ?v_794) ?v_795))) ?v_854) ?v_809) ?v_853) ?v_878) ?v_877) (and (and (and (and (and (and (and (and (and (= ?v_808 1) (or (or (or (and (and (and (and (= ?v_852 0) (not ?v_875)) (= (- x_156 x_157) 0)) ?v_809) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 1) ?v_866) ?v_855) ?v_867) ?v_856) (ite ?v_836 (= ?v_43 1) ?v_810)) (ite ?v_837 (= ?v_44 1) ?v_812)) (ite ?v_838 (= ?v_45 1) ?v_813)) (ite ?v_839 (= ?v_46 1) ?v_814)) (ite ?v_840 (= ?v_47 1) ?v_815)) (ite ?v_841 (= ?v_48 1) ?v_816)) (ite ?v_842 (= ?v_49 1) ?v_817)) (ite ?v_843 (= ?v_50 1) ?v_818)) (ite ?v_844 (= ?v_51 1) ?v_819)) (ite ?v_845 (= ?v_52 1) ?v_820)) (ite ?v_846 (= ?v_53 1) ?v_821)) (ite ?v_847 (= ?v_54 1) ?v_822)) x_178) ?v_755) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828) ?v_681) ?v_679) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 2) ?v_869) ?v_858) ?v_870) ?v_859) (ite ?v_836 (= ?v_43 2) ?v_810)) (ite ?v_837 (= ?v_44 2) ?v_812)) (ite ?v_838 (= ?v_45 2) ?v_813)) (ite ?v_839 (= ?v_46 2) ?v_814)) (ite ?v_840 (= ?v_47 2) ?v_815)) (ite ?v_841 (= ?v_48 2) ?v_816)) (ite ?v_842 (= ?v_49 2) ?v_817)) (ite ?v_843 (= ?v_50 2) ?v_818)) (ite ?v_844 (= ?v_51 2) ?v_819)) (ite ?v_845 (= ?v_52 2) ?v_820)) (ite ?v_846 (= ?v_53 2) ?v_821)) (ite ?v_847 (= ?v_54 2) ?v_822)) ?v_848) ?v_849) x_180) ?v_758) ?v_825) ?v_826) ?v_827) ?v_828) ?v_850) ?v_851) ?v_691) ?v_686) ?v_831) ?v_832) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 3) ?v_871) ?v_861) ?v_872) ?v_862) (ite ?v_836 (= ?v_43 3) ?v_810)) (ite ?v_837 (= ?v_44 3) ?v_812)) (ite ?v_838 (= ?v_45 3) ?v_813)) (ite ?v_839 (= ?v_46 3) ?v_814)) (ite ?v_840 (= ?v_47 3) ?v_815)) (ite ?v_841 (= ?v_48 3) ?v_816)) (ite ?v_842 (= ?v_49 3) ?v_817)) (ite ?v_843 (= ?v_50 3) ?v_818)) (ite ?v_844 (= ?v_51 3) ?v_819)) (ite ?v_845 (= ?v_52 3) ?v_820)) (ite ?v_846 (= ?v_53 3) ?v_821)) (ite ?v_847 (= ?v_54 3) ?v_822)) ?v_848) ?v_849) ?v_823) ?v_824) x_182) ?v_761) ?v_827) ?v_828) ?v_850) ?v_851) ?v_829) ?v_830) ?v_700) ?v_698) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_835 4) ?v_873) ?v_863) ?v_874) ?v_864) (ite ?v_836 (= ?v_43 4) ?v_810)) (ite ?v_837 (= ?v_44 4) ?v_812)) (ite ?v_838 (= ?v_45 4) ?v_813)) (ite ?v_839 (= ?v_46 4) ?v_814)) (ite ?v_840 (= ?v_47 4) ?v_815)) (ite ?v_841 (= ?v_48 4) ?v_816)) (ite ?v_842 (= ?v_49 4) ?v_817)) (ite ?v_843 (= ?v_50 4) ?v_818)) (ite ?v_844 (= ?v_51 4) ?v_819)) (ite ?v_845 (= ?v_52 4) ?v_820)) (ite ?v_846 (= ?v_53 4) ?v_821)) (ite ?v_847 (= ?v_54 4) ?v_822)) ?v_848) ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) x_184) ?v_763) ?v_850) ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) ?v_706) ?v_704))) (and (and (and (and (= ?v_852 1) ?v_853) ?v_809) ?v_854) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 1) x_142) ?v_855) x_123) ?v_856) (= ?v_860 1)) ?v_766) x_179) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828) x_158) ?v_679) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 2) x_144) ?v_858) x_125) ?v_859) (= ?v_860 2)) ?v_848) ?v_849) ?v_769) x_181) ?v_825) ?v_826) ?v_827) ?v_828) ?v_850) ?v_851) x_160) ?v_686) ?v_831) ?v_832) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 3) x_146) ?v_861) x_127) ?v_862) (= ?v_860 3)) ?v_848) ?v_849) ?v_823) ?v_824) ?v_771) x_183) ?v_827) ?v_828) ?v_850) ?v_851) ?v_829) ?v_830) x_162) ?v_698) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_857 4) x_148) ?v_863) x_129) ?v_864) (= ?v_860 4)) ?v_848) ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) ?v_773) x_185) ?v_850) ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) x_164) ?v_704)))) (and (and (and (and (= ?v_852 2) (= ?v_865 1)) ?v_853) ?v_854) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 1) ?v_866) x_143) ?v_867) x_124) ?v_766) ?v_755) ?v_823) ?v_824) ?v_825) ?v_826) ?v_827) ?v_828) ?v_681) x_159) ?v_829) ?v_830) ?v_831) ?v_832) ?v_833) ?v_834) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 2) ?v_869) x_145) ?v_870) x_126) ?v_848) ?v_849) ?v_769) ?v_758) ?v_825) ?v_826) ?v_827) ?v_828) ?v_850) ?v_851) ?v_691) x_161) ?v_831) ?v_832) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 3) ?v_871) x_147) ?v_872) x_128) ?v_848) ?v_849) ?v_823) ?v_824) ?v_771) ?v_761) ?v_827) ?v_828) ?v_850) ?v_851) ?v_829) ?v_830) ?v_700) x_163) ?v_833) ?v_834)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_868 4) ?v_873) x_149) ?v_874) x_130) ?v_848) ?v_849) ?v_823) ?v_824) ?v_825) ?v_826) ?v_773) ?v_763) ?v_850) ?v_851) ?v_829) ?v_830) ?v_831) ?v_832) ?v_706) x_165)))) (and (and (and (and (and (and (and (= ?v_852 3) (= (- x_132 x_157) 0)) ?v_875) ?v_876) (= ?v_42 0)) ?v_877) ?v_853) ?v_878))) ?v_802) ?v_803) ?v_794) ?v_796) ?v_793) ?v_788) ?v_795) ?v_797))) (or (and (and (and (and (and (and (= ?v_909 0) (or (or (or (and (and (and (and (and (and (and (= ?v_884 1) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_882) ?v_880) ?v_883) ?v_881) x_134) ?v_779) x_142) ?v_855) (and (and (and (and (and (and (and ?v_886 x_79) ?v_880) x_48) ?v_881) ?v_781) x_135) ?v_894)) (and (and (and (and (and (and ?v_890 ?v_882) x_80) x_134) x_135) ?v_866) x_143)) (and (and (and (and (and (and (and (and ?v_892 x_79) x_80) ?v_883) x_49) ?v_781) ?v_779) ?v_866) ?v_855))) ?v_904) ?v_889) ?v_895) ?v_896) ?v_897) ?v_898) (and (and (and (and (and (and (and (= ?v_884 2) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_891) ?v_887) ?v_893) ?v_888) x_136) ?v_786) x_144) ?v_858) (and (and (and (and (and (and (and ?v_886 x_81) ?v_887) x_50) ?v_888) ?v_790) x_137) ?v_889)) (and (and (and (and (and (and ?v_890 ?v_891) x_82) x_136) x_137) ?v_869) x_145)) (and (and (and (and (and (and (and (and ?v_892 x_81) x_82) ?v_893) x_51) ?v_790) ?v_786) ?v_869) ?v_858))) ?v_903) ?v_894) ?v_895) ?v_896) ?v_897) ?v_898)) (and (and (and (and (and (and (and (= ?v_884 3) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_901) ?v_899) ?v_902) ?v_900) x_138) ?v_798) x_146) ?v_861) (and (and (and (and (and (and (and ?v_886 x_83) ?v_899) x_52) ?v_900) ?v_800) x_139) ?v_896)) (and (and (and (and (and (and ?v_890 ?v_901) x_84) x_138) x_139) ?v_871) x_147)) (and (and (and (and (and (and (and (and ?v_892 x_83) x_84) ?v_902) x_53) ?v_800) ?v_798) ?v_871) ?v_861))) ?v_903) ?v_894) ?v_904) ?v_889) ?v_897) ?v_898)) (and (and (and (and (and (and (and (= ?v_884 4) (or (or (or (and (and (and (and (and (and (and (and ?v_885 ?v_907) ?v_905) ?v_908) ?v_906) x_140) ?v_804) x_148) ?v_863) (and (and (and (and (and (and (and ?v_886 x_85) ?v_905) x_54) ?v_906) ?v_806) x_141) ?v_898)) (and (and (and (and (and (and ?v_890 ?v_907) x_86) x_140) x_141) ?v_873) x_149)) (and (and (and (and (and (and (and (and ?v_892 x_85) x_86) ?v_908) x_55) ?v_806) ?v_804) ?v_873) ?v_863))) ?v_903) ?v_894) ?v_904) ?v_889) ?v_895) ?v_896))) ?v_955) ?v_910) ?v_954) ?v_979) ?v_978) (and (and (and (and (and (and (and (and (and (= ?v_909 1) (or (or (or (and (and (and (and (= ?v_953 0) (not ?v_976)) (= (- x_101 x_102) 0)) ?v_910) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 1) ?v_967) ?v_956) ?v_968) ?v_957) (ite ?v_937 (= ?v_29 1) ?v_911)) (ite ?v_938 (= ?v_30 1) ?v_913)) (ite ?v_939 (= ?v_31 1) ?v_914)) (ite ?v_940 (= ?v_32 1) ?v_915)) (ite ?v_941 (= ?v_33 1) ?v_916)) (ite ?v_942 (= ?v_34 1) ?v_917)) (ite ?v_943 (= ?v_35 1) ?v_918)) (ite ?v_944 (= ?v_36 1) ?v_919)) (ite ?v_945 (= ?v_37 1) ?v_920)) (ite ?v_946 (= ?v_38 1) ?v_921)) (ite ?v_947 (= ?v_39 1) ?v_922)) (ite ?v_948 (= ?v_40 1) ?v_923)) x_123) ?v_856) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929) ?v_782) ?v_780) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 2) ?v_970) ?v_959) ?v_971) ?v_960) (ite ?v_937 (= ?v_29 2) ?v_911)) (ite ?v_938 (= ?v_30 2) ?v_913)) (ite ?v_939 (= ?v_31 2) ?v_914)) (ite ?v_940 (= ?v_32 2) ?v_915)) (ite ?v_941 (= ?v_33 2) ?v_916)) (ite ?v_942 (= ?v_34 2) ?v_917)) (ite ?v_943 (= ?v_35 2) ?v_918)) (ite ?v_944 (= ?v_36 2) ?v_919)) (ite ?v_945 (= ?v_37 2) ?v_920)) (ite ?v_946 (= ?v_38 2) ?v_921)) (ite ?v_947 (= ?v_39 2) ?v_922)) (ite ?v_948 (= ?v_40 2) ?v_923)) ?v_949) ?v_950) x_125) ?v_859) ?v_926) ?v_927) ?v_928) ?v_929) ?v_951) ?v_952) ?v_792) ?v_787) ?v_932) ?v_933) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 3) ?v_972) ?v_962) ?v_973) ?v_963) (ite ?v_937 (= ?v_29 3) ?v_911)) (ite ?v_938 (= ?v_30 3) ?v_913)) (ite ?v_939 (= ?v_31 3) ?v_914)) (ite ?v_940 (= ?v_32 3) ?v_915)) (ite ?v_941 (= ?v_33 3) ?v_916)) (ite ?v_942 (= ?v_34 3) ?v_917)) (ite ?v_943 (= ?v_35 3) ?v_918)) (ite ?v_944 (= ?v_36 3) ?v_919)) (ite ?v_945 (= ?v_37 3) ?v_920)) (ite ?v_946 (= ?v_38 3) ?v_921)) (ite ?v_947 (= ?v_39 3) ?v_922)) (ite ?v_948 (= ?v_40 3) ?v_923)) ?v_949) ?v_950) ?v_924) ?v_925) x_127) ?v_862) ?v_928) ?v_929) ?v_951) ?v_952) ?v_930) ?v_931) ?v_801) ?v_799) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_936 4) ?v_974) ?v_964) ?v_975) ?v_965) (ite ?v_937 (= ?v_29 4) ?v_911)) (ite ?v_938 (= ?v_30 4) ?v_913)) (ite ?v_939 (= ?v_31 4) ?v_914)) (ite ?v_940 (= ?v_32 4) ?v_915)) (ite ?v_941 (= ?v_33 4) ?v_916)) (ite ?v_942 (= ?v_34 4) ?v_917)) (ite ?v_943 (= ?v_35 4) ?v_918)) (ite ?v_944 (= ?v_36 4) ?v_919)) (ite ?v_945 (= ?v_37 4) ?v_920)) (ite ?v_946 (= ?v_38 4) ?v_921)) (ite ?v_947 (= ?v_39 4) ?v_922)) (ite ?v_948 (= ?v_40 4) ?v_923)) ?v_949) ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) x_129) ?v_864) ?v_951) ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) ?v_807) ?v_805))) (and (and (and (and (= ?v_953 1) ?v_954) ?v_910) ?v_955) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 1) x_87) ?v_956) x_68) ?v_957) (= ?v_961 1)) ?v_867) x_124) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929) x_103) ?v_780) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 2) x_89) ?v_959) x_70) ?v_960) (= ?v_961 2)) ?v_949) ?v_950) ?v_870) x_126) ?v_926) ?v_927) ?v_928) ?v_929) ?v_951) ?v_952) x_105) ?v_787) ?v_932) ?v_933) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 3) x_91) ?v_962) x_72) ?v_963) (= ?v_961 3)) ?v_949) ?v_950) ?v_924) ?v_925) ?v_872) x_128) ?v_928) ?v_929) ?v_951) ?v_952) ?v_930) ?v_931) x_107) ?v_799) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_958 4) x_93) ?v_964) x_74) ?v_965) (= ?v_961 4)) ?v_949) ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) ?v_874) x_130) ?v_951) ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) x_109) ?v_805)))) (and (and (and (and (= ?v_953 2) (= ?v_966 1)) ?v_954) ?v_955) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 1) ?v_967) x_88) ?v_968) x_69) ?v_867) ?v_856) ?v_924) ?v_925) ?v_926) ?v_927) ?v_928) ?v_929) ?v_782) x_104) ?v_930) ?v_931) ?v_932) ?v_933) ?v_934) ?v_935) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 2) ?v_970) x_90) ?v_971) x_71) ?v_949) ?v_950) ?v_870) ?v_859) ?v_926) ?v_927) ?v_928) ?v_929) ?v_951) ?v_952) ?v_792) x_106) ?v_932) ?v_933) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 3) ?v_972) x_92) ?v_973) x_73) ?v_949) ?v_950) ?v_924) ?v_925) ?v_872) ?v_862) ?v_928) ?v_929) ?v_951) ?v_952) ?v_930) ?v_931) ?v_801) x_108) ?v_934) ?v_935)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_969 4) ?v_974) x_94) ?v_975) x_75) ?v_949) ?v_950) ?v_924) ?v_925) ?v_926) ?v_927) ?v_874) ?v_864) ?v_951) ?v_952) ?v_930) ?v_931) ?v_932) ?v_933) ?v_807) x_110)))) (and (and (and (and (and (and (and (= ?v_953 3) (= (- x_77 x_102) 0)) ?v_976) ?v_977) (= ?v_28 0)) ?v_978) ?v_954) ?v_979))) ?v_903) ?v_904) ?v_895) ?v_897) ?v_894) ?v_889) ?v_896) ?v_898))) (or (and (and (and (and (and (and (= ?v_1010 0) (or (or (or (and (and (and (and (and (and (and (= ?v_985 1) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_980) ?v_981) ?v_984) ?v_983) x_79) ?v_880) x_87) ?v_956) (and (and (and (and (and (and (and ?v_989 x_0) ?v_981) x_16) ?v_983) ?v_882) x_80) ?v_995)) (and (and (and (and (and (and ?v_992 ?v_980) x_1) x_79) x_80) ?v_967) x_88)) (and (and (and (and (and (and (and (and ?v_993 x_0) x_1) ?v_984) x_17) ?v_882) ?v_880) ?v_967) ?v_956))) ?v_1005) ?v_991) ?v_996) ?v_997) ?v_998) ?v_999) (and (and (and (and (and (and (and (= ?v_985 2) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_987) ?v_988) ?v_994) ?v_990) x_81) ?v_887) x_89) ?v_959) (and (and (and (and (and (and (and ?v_989 x_2) ?v_988) x_18) ?v_990) ?v_891) x_82) ?v_991)) (and (and (and (and (and (and ?v_992 ?v_987) x_3) x_81) x_82) ?v_970) x_90)) (and (and (and (and (and (and (and (and ?v_993 x_2) x_3) ?v_994) x_19) ?v_891) ?v_887) ?v_970) ?v_959))) ?v_1004) ?v_995) ?v_996) ?v_997) ?v_998) ?v_999)) (and (and (and (and (and (and (and (= ?v_985 3) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_1000) ?v_1001) ?v_1003) ?v_1002) x_83) ?v_899) x_91) ?v_962) (and (and (and (and (and (and (and ?v_989 x_4) ?v_1001) x_20) ?v_1002) ?v_901) x_84) ?v_997)) (and (and (and (and (and (and ?v_992 ?v_1000) x_5) x_83) x_84) ?v_972) x_92)) (and (and (and (and (and (and (and (and ?v_993 x_4) x_5) ?v_1003) x_21) ?v_901) ?v_899) ?v_972) ?v_962))) ?v_1004) ?v_995) ?v_1005) ?v_991) ?v_998) ?v_999)) (and (and (and (and (and (and (and (= ?v_985 4) (or (or (or (and (and (and (and (and (and (and (and ?v_986 ?v_1006) ?v_1007) ?v_1009) ?v_1008) x_85) ?v_905) x_93) ?v_964) (and (and (and (and (and (and (and ?v_989 x_6) ?v_1007) x_22) ?v_1008) ?v_907) x_86) ?v_999)) (and (and (and (and (and (and ?v_992 ?v_1006) x_7) x_85) x_86) ?v_974) x_94)) (and (and (and (and (and (and (and (and ?v_993 x_6) x_7) ?v_1009) x_23) ?v_907) ?v_905) ?v_974) ?v_964))) ?v_1004) ?v_995) ?v_1005) ?v_991) ?v_996) ?v_997))) ?v_1072) ?v_1011) ?v_1071) ?v_1080) ?v_1079) (and (and (and (and (and (and (and (and (and (= ?v_1010 1) (or (or (or (and (and (and (and (= ?v_1070 0) (not ?v_1077)) (= (- x_46 x_47) 0)) ?v_1011) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 1) ?v_1012) ?v_1013) ?v_1014) ?v_1015) (ite ?v_1046 (= ?v_15 1) ?v_1016)) (ite ?v_1047 (= ?v_16 1) ?v_1018)) (ite ?v_1048 (= ?v_17 1) ?v_1019)) (ite ?v_1049 (= ?v_18 1) ?v_1020)) (ite ?v_1050 (= ?v_19 1) ?v_1021)) (ite ?v_1051 (= ?v_20 1) ?v_1022)) (ite ?v_1052 (= ?v_21 1) ?v_1023)) (ite ?v_1053 (= ?v_22 1) ?v_1024)) (ite ?v_1054 (= ?v_23 1) ?v_1025)) (ite ?v_1055 (= ?v_24 1) ?v_1026)) (ite ?v_1056 (= ?v_25 1) ?v_1027)) (ite ?v_1057 (= ?v_26 1) ?v_1028)) x_68) ?v_957) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_883) ?v_881) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 2) ?v_1042) ?v_1043) ?v_1044) ?v_1045) (ite ?v_1046 (= ?v_15 2) ?v_1016)) (ite ?v_1047 (= ?v_16 2) ?v_1018)) (ite ?v_1048 (= ?v_17 2) ?v_1019)) (ite ?v_1049 (= ?v_18 2) ?v_1020)) (ite ?v_1050 (= ?v_19 2) ?v_1021)) (ite ?v_1051 (= ?v_20 2) ?v_1022)) (ite ?v_1052 (= ?v_21 2) ?v_1023)) (ite ?v_1053 (= ?v_22 2) ?v_1024)) (ite ?v_1054 (= ?v_23 2) ?v_1025)) (ite ?v_1055 (= ?v_24 2) ?v_1026)) (ite ?v_1056 (= ?v_25 2) ?v_1027)) (ite ?v_1057 (= ?v_26 2) ?v_1028)) ?v_1058) ?v_1059) x_70) ?v_960) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_893) ?v_888) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 3) ?v_1062) ?v_1063) ?v_1064) ?v_1065) (ite ?v_1046 (= ?v_15 3) ?v_1016)) (ite ?v_1047 (= ?v_16 3) ?v_1018)) (ite ?v_1048 (= ?v_17 3) ?v_1019)) (ite ?v_1049 (= ?v_18 3) ?v_1020)) (ite ?v_1050 (= ?v_19 3) ?v_1021)) (ite ?v_1051 (= ?v_20 3) ?v_1022)) (ite ?v_1052 (= ?v_21 3) ?v_1023)) (ite ?v_1053 (= ?v_22 3) ?v_1024)) (ite ?v_1054 (= ?v_23 3) ?v_1025)) (ite ?v_1055 (= ?v_24 3) ?v_1026)) (ite ?v_1056 (= ?v_25 3) ?v_1027)) (ite ?v_1057 (= ?v_26 3) ?v_1028)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) x_72) ?v_963) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_902) ?v_900) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1041 4) ?v_1066) ?v_1067) ?v_1068) ?v_1069) (ite ?v_1046 (= ?v_15 4) ?v_1016)) (ite ?v_1047 (= ?v_16 4) ?v_1018)) (ite ?v_1048 (= ?v_17 4) ?v_1019)) (ite ?v_1049 (= ?v_18 4) ?v_1020)) (ite ?v_1050 (= ?v_19 4) ?v_1021)) (ite ?v_1051 (= ?v_20 4) ?v_1022)) (ite ?v_1052 (= ?v_21 4) ?v_1023)) (ite ?v_1053 (= ?v_22 4) ?v_1024)) (ite ?v_1054 (= ?v_23 4) ?v_1025)) (ite ?v_1055 (= ?v_24 4) ?v_1026)) (ite ?v_1056 (= ?v_25 4) ?v_1027)) (ite ?v_1057 (= ?v_26 4) ?v_1028)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) x_74) ?v_965) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_908) ?v_906))) (and (and (and (and (= ?v_1070 1) ?v_1071) ?v_1011) ?v_1072) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 1) x_8) ?v_1013) x_24) ?v_1015) (= ?v_1074 1)) ?v_968) x_69) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034) x_48) ?v_881) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 2) x_10) ?v_1043) x_26) ?v_1045) (= ?v_1074 2)) ?v_1058) ?v_1059) ?v_971) x_71) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_1060) ?v_1061) x_50) ?v_888) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 3) x_12) ?v_1063) x_28) ?v_1065) (= ?v_1074 3)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_973) x_73) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_1035) ?v_1036) x_52) ?v_900) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1073 4) x_14) ?v_1067) x_30) ?v_1069) (= ?v_1074 4)) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_975) x_75) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) x_54) ?v_906)))) (and (and (and (and (= ?v_1070 2) (= ?v_1075 1)) ?v_1071) ?v_1072) (or (or (or (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 1) ?v_1012) x_9) ?v_1014) x_25) ?v_968) ?v_957) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_883) x_49) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_1039) ?v_1040) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 2) ?v_1042) x_11) ?v_1044) x_27) ?v_1058) ?v_1059) ?v_971) ?v_960) ?v_1031) ?v_1032) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_893) x_51) ?v_1037) ?v_1038) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 3) ?v_1062) x_13) ?v_1064) x_29) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_973) ?v_963) ?v_1033) ?v_1034) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_902) x_53) ?v_1039) ?v_1040)) (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (and (= ?v_1076 4) ?v_1066) x_15) ?v_1068) x_31) ?v_1058) ?v_1059) ?v_1029) ?v_1030) ?v_1031) ?v_1032) ?v_975) ?v_965) ?v_1060) ?v_1061) ?v_1035) ?v_1036) ?v_1037) ?v_1038) ?v_908) x_55)))) (and (and (and (and (and (and (and (= ?v_1070 3) (= (- x_44 x_47) 0)) ?v_1077) ?v_1078) (= ?v_14 0)) ?v_1079) ?v_1071) ?v_1080))) ?v_1004) ?v_1005) ?v_996) ?v_998) ?v_995) ?v_991) ?v_997) ?v_999))) (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (or (and ?v_1082 (or (or ?v_1081 ?v_1083) ?v_1084)) (and ?v_1081 (or (or ?v_1082 ?v_1083) ?v_1084))) (and ?v_1083 (or ?v_1085 ?v_1084))) (and ?v_1084 (or ?v_1085 ?v_1083))) (and ?v_1087 (or (or ?v_1086 ?v_1088) ?v_1089))) (and ?v_1086 (or (or ?v_1087 ?v_1088) ?v_1089))) (and ?v_1088 (or ?v_1090 ?v_1089))) (and ?v_1089 (or ?v_1090 ?v_1088))) (and ?v_1092 (or (or ?v_1091 ?v_1093) ?v_1094))) (and ?v_1091 (or (or ?v_1092 ?v_1093) ?v_1094))) (and ?v_1093 (or ?v_1095 ?v_1094))) (and ?v_1094 (or ?v_1095 ?v_1093))) (and ?v_1097 (or (or ?v_1096 ?v_1098) ?v_1099))) (and ?v_1096 (or (or ?v_1097 ?v_1098) ?v_1099))) (and ?v_1098 (or ?v_1100 ?v_1099))) (and ?v_1099 (or ?v_1100 ?v_1098))) (and ?v_1102 (or (or ?v_1101 ?v_1103) ?v_1104))) (and ?v_1101 (or (or ?v_1102 ?v_1103) ?v_1104))) (and ?v_1103 (or ?v_1105 ?v_1104))) (and ?v_1104 (or ?v_1105 ?v_1103))) (and ?v_1107 (or (or ?v_1106 ?v_1108) ?v_1109))) (and ?v_1106 (or (or ?v_1107 ?v_1108) ?v_1109))) (and ?v_1108 (or ?v_1110 ?v_1109))) (and ?v_1109 (or ?v_1110 ?v_1108))) (and ?v_1112 (or (or ?v_1111 ?v_1113) ?v_1114))) (and ?v_1111 (or (or ?v_1112 ?v_1113) ?v_1114))) (and ?v_1113 (or ?v_1115 ?v_1114))) (and ?v_1114 (or ?v_1115 ?v_1113))) (and ?v_1117 (or (or ?v_1116 ?v_1118) ?v_1119))) (and ?v_1116 (or (or ?v_1117 ?v_1118) ?v_1119))) (and ?v_1118 (or ?v_1120 ?v_1119))) (and ?v_1119 (or ?v_1120 ?v_1118))) (and ?v_1122 (or (or ?v_1121 ?v_1123) ?v_1124))) (and ?v_1121 (or (or ?v_1122 ?v_1123) ?v_1124))) (and ?v_1123 (or ?v_1125 ?v_1124))) (and ?v_1124 (or ?v_1125 ?v_1123))) (and ?v_1127 (or (or ?v_1126 ?v_1128) ?v_1129))) (and ?v_1126 (or (or ?v_1127 ?v_1128) ?v_1129))) (and ?v_1128 (or ?v_1130 ?v_1129))) (and ?v_1129 (or ?v_1130 ?v_1128)))) (or ?v_1013 ?v_1012)) (or ?v_1043 ?v_1042)) (or ?v_1063 ?v_1062)) (or ?v_1067 ?v_1066)) (or ?v_1015 ?v_1014)) (or ?v_1045 ?v_1044)) (or ?v_1065 ?v_1064)) (or ?v_1069 ?v_1068)) (or ?v_957 ?v_968)) (or ?v_960 ?v_971)) (or ?v_963 ?v_973)) (or ?v_965 ?v_975)) (or ?v_956 ?v_967)) (or ?v_959 ?v_970)) (or ?v_962 ?v_972)) (or ?v_964 ?v_974)) (or ?v_856 ?v_867)) (or ?v_859 ?v_870)) (or ?v_862 ?v_872)) (or ?v_864 ?v_874)) (or ?v_855 ?v_866)) (or ?v_858 ?v_869)) (or ?v_861 ?v_871)) (or ?v_863 ?v_873)) (or ?v_755 ?v_766)) (or ?v_758 ?v_769)) (or ?v_761 ?v_771)) (or ?v_763 ?v_773)) (or ?v_754 ?v_765)) (or ?v_757 ?v_768)) (or ?v_760 ?v_770)) (or ?v_762 ?v_772)) (or ?v_654 ?v_665)) (or ?v_657 ?v_668)) (or ?v_660 ?v_670)) (or ?v_662 ?v_672)) (or ?v_653 ?v_664)) (or ?v_656 ?v_667)) (or ?v_659 ?v_669)) (or ?v_661 ?v_671)) (or ?v_553 ?v_564)) (or ?v_556 ?v_567)) (or ?v_559 ?v_569)) (or ?v_561 ?v_571)) (or ?v_552 ?v_563)) (or ?v_555 ?v_566)) (or ?v_558 ?v_568)) (or ?v_560 ?v_570)) (or ?v_452 ?v_463)) (or ?v_455 ?v_466)) (or ?v_458 ?v_468)) (or ?v_460 ?v_470)) (or ?v_451 ?v_462)) (or ?v_454 ?v_465)) (or ?v_457 ?v_467)) (or ?v_459 ?v_469)) (or ?v_351 ?v_362)) (or ?v_354 ?v_365)) (or ?v_357 ?v_367)) (or ?v_359 ?v_369)) (or ?v_350 ?v_361)) (or ?v_353 ?v_364)) (or ?v_356 ?v_366)) (or ?v_358 ?v_368)) (or ?v_235 ?v_250)) (or ?v_239 ?v_256)) (or ?v_243 ?v_261)) (or ?v_246 ?v_266)) (or ?v_234 ?v_249)) (or ?v_238 ?v_255)) (or ?v_242 ?v_260)) (or ?v_245 ?v_265)) (or ?v_252 ?v_251)) (or ?v_258 ?v_257)) (or ?v_263 ?v_262)) (or ?v_268 ?v_267)) (or ?v_149 ?v_148)) (or ?v_163 ?v_162)) (or ?v_176 ?v_175)) (or ?v_186 ?v_185))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) +(check-sat) +(exit) -- 2.30.2