From ea54c6ed118928d8767c35e60d5de6c6ef877d00 Mon Sep 17 00:00:00 2001 From: ajreynol Date: Wed, 5 Apr 2017 09:01:55 -0500 Subject: Add non-linear regressions, disable nlAlgSubs, do not do rep checking for NONLINEAR_MULT terms. Ensure shared terms have correct model values in non-linear solver. --- src/options/arith_options | 2 +- src/theory/arith/nonlinear_extension.cpp | 27 + src/theory/theory_model.cpp | 17 +- test/Makefile.am | 1 + test/regress/regress0/Makefile.am | 2 +- test/regress/regress0/nl/Makefile | 8 + test/regress/regress0/nl/Makefile.am | 60 + test/regress/regress0/nl/bug698.smt2 | 28 + test/regress/regress0/nl/coeff-sat.smt2 | 16 + test/regress/regress0/nl/coeff-unsat-base.smt2 | 16 + test/regress/regress0/nl/coeff-unsat.smt2 | 16 + test/regress/regress0/nl/combine.smt2 | 13 + test/regress/regress0/nl/disj-eval.smt2 | 14 + test/regress/regress0/nl/dist-big.smt2 | 16 + .../regress0/nl/magnitude-wrong-1020-m.smt2 | 72 + test/regress/regress0/nl/metitarski-1025.smt2 | 30 + test/regress/regress0/nl/metitarski-3-4.smt2 | 29 + test/regress/regress0/nl/metitarski_3_4_2e.smt2 | 30 + test/regress/regress0/nl/mult-po.smt2 | 20 + test/regress/regress0/nl/nia-wrong-tl.smt2 | 15274 +++++++++++++++++++ test/regress/regress0/nl/nl-help-unsat-quant.smt2 | 419 + test/regress/regress0/nl/nl-unk-quant.smt2 | 29 + test/regress/regress0/nl/nt-lemmas-bad.smt2 | 29 + test/regress/regress0/nl/ones.smt2 | 18 + test/regress/regress0/nl/poly-1025.smt2 | 29 + test/regress/regress0/nl/quant-nl.smt2 | 857 ++ test/regress/regress0/nl/red-exp.smt2 | 11 + test/regress/regress0/nl/rewriting-sums.smt2 | 18 + test/regress/regress0/nl/simple-mono-unsat.smt2 | 18 + test/regress/regress0/nl/simple-mono.smt2 | 17 + test/regress/regress0/nl/subs0-unsat-confirm.smt2 | 18 + test/regress/regress0/nl/very-easy-sat.smt2 | 30 + test/regress/regress0/nl/very-simple-unsat.smt2 | 15 + test/regress/regress0/nl/zero-subset.smt2 | 15 + 34 files changed, 17205 insertions(+), 9 deletions(-) create mode 100644 test/regress/regress0/nl/Makefile create mode 100644 test/regress/regress0/nl/Makefile.am create mode 100644 test/regress/regress0/nl/bug698.smt2 create mode 100644 test/regress/regress0/nl/coeff-sat.smt2 create mode 100644 test/regress/regress0/nl/coeff-unsat-base.smt2 create mode 100644 test/regress/regress0/nl/coeff-unsat.smt2 create mode 100644 test/regress/regress0/nl/combine.smt2 create mode 100644 test/regress/regress0/nl/disj-eval.smt2 create mode 100644 test/regress/regress0/nl/dist-big.smt2 create mode 100644 test/regress/regress0/nl/magnitude-wrong-1020-m.smt2 create mode 100644 test/regress/regress0/nl/metitarski-1025.smt2 create mode 100644 test/regress/regress0/nl/metitarski-3-4.smt2 create mode 100644 test/regress/regress0/nl/metitarski_3_4_2e.smt2 create mode 100644 test/regress/regress0/nl/mult-po.smt2 create mode 100644 test/regress/regress0/nl/nia-wrong-tl.smt2 create mode 100644 test/regress/regress0/nl/nl-help-unsat-quant.smt2 create mode 100644 test/regress/regress0/nl/nl-unk-quant.smt2 create mode 100644 test/regress/regress0/nl/nt-lemmas-bad.smt2 create mode 100644 test/regress/regress0/nl/ones.smt2 create mode 100644 test/regress/regress0/nl/poly-1025.smt2 create mode 100644 test/regress/regress0/nl/quant-nl.smt2 create mode 100644 test/regress/regress0/nl/red-exp.smt2 create mode 100644 test/regress/regress0/nl/rewriting-sums.smt2 create mode 100644 test/regress/regress0/nl/simple-mono-unsat.smt2 create mode 100644 test/regress/regress0/nl/simple-mono.smt2 create mode 100644 test/regress/regress0/nl/subs0-unsat-confirm.smt2 create mode 100644 test/regress/regress0/nl/very-easy-sat.smt2 create mode 100644 test/regress/regress0/nl/very-simple-unsat.smt2 create mode 100644 test/regress/regress0/nl/zero-subset.smt2 diff --git a/src/options/arith_options b/src/options/arith_options index 6f76758e3..36f0e6255 100644 --- a/src/options/arith_options +++ b/src/options/arith_options @@ -180,7 +180,7 @@ option nlAlgEntailConflicts --nl-alg-ent-conf bool :default false option nlAlgRewrites --nl-alg-rewrite bool :default true do rewrites in non-linear solver -option nlAlgSolveSubs --nl-alg-solve-subs bool :default true +option nlAlgSolveSubs --nl-alg-solve-subs bool :default false do solving for determining constant substitutions option nlAlgPurify --nl-alg-purify bool :default false diff --git a/src/theory/arith/nonlinear_extension.cpp b/src/theory/arith/nonlinear_extension.cpp index 366bff4eb..558a07e39 100644 --- a/src/theory/arith/nonlinear_extension.cpp +++ b/src/theory/arith/nonlinear_extension.cpp @@ -526,6 +526,7 @@ bool NonLinearExtentionSubstitutionSolver::setSubstitutionConst( Node m_t = result.term; Node eq = m_t.eqNode(r_c); Node v_c = QuantArith::solveEqualityFor(eq, v); + Trace("nl-subs-debug") << "Solved equality " << eq << " for " << v << ", got = " << v_c << std::endl; if (!v_c.isNull()) { Assert(v_c.isConst()); if (new_const.find(v) == new_const.end()) { @@ -1789,9 +1790,35 @@ void NonlinearExtension::check(Theory::Effort e) { const Assertion& assertion = *it; assertions.push_back(assertion.assertion); } + const std::set false_asserts = getFalseInModel(assertions); if (!false_asserts.empty()) { checkLastCall(assertions, false_asserts); + }else{ + //must ensure that shared terms are equal to their concrete value + std::vector< Node > lemmas; + for (context::CDList::const_iterator its = d_containing.shared_terms_begin(); + its != d_containing.shared_terms_end(); ++its) { + TNode shared_term = *its; + Node stv0 = computeModelValue( shared_term, 0 ); + Node stv1 = computeModelValue( shared_term, 1 ); + + if( stv0!=stv1 ){ + Trace("nl-alg-mv") << "Bad shared term value : " << shared_term << " : " << stv1 << ", actual is " << stv0 << std::endl; + //split on the value, FIXME : this is non-terminating in general, improve this + Node lem = shared_term.eqNode(stv0); + lem = Rewriter::rewrite(lem); + d_containing.getValuation().ensureLiteral(lem); + d_containing.getOutputChannel().requirePhase(lem, true); + lem = NodeManager::currentNM()->mkNode(kind::OR, lem, lem.negate()); + lemmas.push_back(lem); + } + } + if( !lemmas.empty() ){ + int lemmas_proc = flushLemmas(lemmas); + Trace("nl-alg-mv") << "...added " << lemmas_proc << " shared term split lemmas." << std::endl; + Assert( lemmas_proc>0 ); + } } } } diff --git a/src/theory/theory_model.cpp b/src/theory/theory_model.cpp index 4de0d6a54..c064040d9 100644 --- a/src/theory/theory_model.cpp +++ b/src/theory/theory_model.cpp @@ -991,13 +991,16 @@ void TheoryEngineModelBuilder::debugCheckModel(Model* m){ Node n = *eqc_i; static int repCheckInstance = 0; ++repCheckInstance; - - Debug("check-model::rep-checking") - << "( " << repCheckInstance <<") " - << "n: " << n << endl - << "getValue(n): " << tm->getValue(n) << endl - << "rep: " << rep << endl; - Assert(tm->getValue(*eqc_i) == rep, "run with -d check-model::rep-checking for details"); + + // non-linear mult is not necessarily accurate wrt getValue + if( n.getKind()!=kind::NONLINEAR_MULT ){ + Debug("check-model::rep-checking") + << "( " << repCheckInstance <<") " + << "n: " << n << endl + << "getValue(n): " << tm->getValue(n) << endl + << "rep: " << rep << endl; + Assert(tm->getValue(*eqc_i) == rep, "run with -d check-model::rep-checking for details"); + } } } #endif /* CVC4_ASSERTIONS */ diff --git a/test/Makefile.am b/test/Makefile.am index 89ac66a3a..31f23e500 100644 --- a/test/Makefile.am +++ b/test/Makefile.am @@ -42,6 +42,7 @@ subdirs_to_check = \ regress/regress0/expect \ regress/regress0/fmf \ regress/regress0/lemmas \ + regress/regress0/nl \ regress/regress0/parser \ regress/regress0/precedence \ regress/regress0/preprocess \ diff --git a/test/regress/regress0/Makefile.am b/test/regress/regress0/Makefile.am index 1e533cc61..b74706e17 100644 --- a/test/regress/regress0/Makefile.am +++ b/test/regress/regress0/Makefile.am @@ -1,4 +1,4 @@ -SUBDIRS = . expect arith precedence uf uflra uflia bv arrays aufbv auflia datatypes quantifiers rewriterules lemmas push-pop preprocess tptp unconstrained decision fmf strings sets rels parser sygus sep +SUBDIRS = . expect arith precedence uf uflra uflia bv arrays aufbv auflia datatypes quantifiers rewriterules lemmas push-pop preprocess tptp unconstrained decision fmf strings sets rels parser sygus sep nl DIST_SUBDIRS = $(SUBDIRS) # don't override a BINARY imported from a personal.mk diff --git a/test/regress/regress0/nl/Makefile b/test/regress/regress0/nl/Makefile new file mode 100644 index 000000000..627bdbde9 --- /dev/null +++ b/test/regress/regress0/nl/Makefile @@ -0,0 +1,8 @@ +topdir = ../../../.. +srcdir = test/regress/regress0/nl + +include $(topdir)/Makefile.subdir + +# synonyms for "check" +.PHONY: test +test: check diff --git a/test/regress/regress0/nl/Makefile.am b/test/regress/regress0/nl/Makefile.am new file mode 100644 index 000000000..a422c9045 --- /dev/null +++ b/test/regress/regress0/nl/Makefile.am @@ -0,0 +1,60 @@ +SUBDIRS = . + +# don't override a BINARY imported from a personal.mk +@mk_if@eq ($(BINARY),) +@mk_empty@BINARY = cvc4 +end@mk_if@ + +LOG_COMPILER = @srcdir@/../../run_regression +AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT) + +if AUTOMAKE_1_11 +# old-style (pre-automake 1.12) test harness +TESTS_ENVIRONMENT = \ + $(LOG_COMPILER) \ + $(AM_LOG_FLAGS) $(LOG_FLAGS) +endif + +MAKEFLAGS = -k + +# These are run for all build profiles. +# If a test shouldn't be run in e.g. competition mode, +# put it below in "TESTS +=" +TESTS = \ + quant-nl.smt2 \ + dist-big.smt2 \ + simple-mono.smt2 \ + coeff-sat.smt2 \ + combine.smt2 \ + magnitude-wrong-1020-m.smt2 \ + nl-unk-quant.smt2 \ + mult-po.smt2 \ + very-simple-unsat.smt2 \ + subs0-unsat-confirm.smt2 \ + simple-mono-unsat.smt2 \ + ones.smt2 \ + metitarski_3_4_2e.smt2 \ + metitarski-1025.smt2 \ + poly-1025.smt2 \ + very-easy-sat.smt2 \ + coeff-unsat.smt2 \ + coeff-unsat-base.smt2 \ + red-exp.smt2 \ + zero-subset.smt2 \ + nia-wrong-tl.smt2 \ + nl-help-unsat-quant.smt2 \ + metitarski-3-4.smt2 \ + rewriting-sums.smt2 \ + disj-eval.smt2 + +# unsolved : garbage_collect.cvc + +EXTRA_DIST = $(TESTS) + +# synonyms for "check" +.PHONY: regress regress0 test +regress regress0 test: check + +# do nothing in this subdir +.PHONY: regress1 regress2 regress3 regress4 +regress1 regress2 regress3 regress4: diff --git a/test/regress/regress0/nl/bug698.smt2 b/test/regress/regress0/nl/bug698.smt2 new file mode 100644 index 000000000..4f0d6102b --- /dev/null +++ b/test/regress/regress0/nl/bug698.smt2 @@ -0,0 +1,28 @@ +(set-logic UFNIA) +(set-info :smt-lib-version 2.5) + +(declare-fun fixedAdd() Int) +(assert (= fixedAdd (+ 2 (+ 2 (+ 2 0))))) +(check-sat) + +(define-fun-rec $$add$$ ((a Int)(b Int)) Int + (ite (= b 0) + 0 + (+ a ($$add$$ a (- b 1))))) + +(declare-fun variableAdd() Int) +(assert (= variableAdd ($$add$$ 2 3))) +(check-sat) + +(declare-fun fixedTimes() Int) +(assert (= fixedTimes (* 2 (* 2 (* 2 1))))) +(check-sat) + +(define-fun-rec $$pow$$ ((a Int)(b Int)) Int + (ite (= b 0) + 1 + (* a ($$pow$$ a (- b 1))))) + +(declare-fun variableTimes() Int) +(assert (= variableTimes ($$pow$$ 2 3))) +(check-sat) diff --git a/test/regress/regress0/nl/coeff-sat.smt2 b/test/regress/regress0/nl/coeff-sat.smt2 new file mode 100644 index 000000000..08d189af1 --- /dev/null +++ b/test/regress/regress0/nl/coeff-sat.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (> a 0)) +(assert (> b 0)) + +(assert (>= a (* 3 b))) + +(assert (< (* a a) (* 11 b b))) + +(check-sat) diff --git a/test/regress/regress0/nl/coeff-unsat-base.smt2 b/test/regress/regress0/nl/coeff-unsat-base.smt2 new file mode 100644 index 000000000..e91cae09e --- /dev/null +++ b/test/regress/regress0/nl/coeff-unsat-base.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (> a 0)) +(assert (> b 0)) + +(assert (>= a (* 3 b))) + +(assert (< (* a a) (* 3 a b))) + +(check-sat) diff --git a/test/regress/regress0/nl/coeff-unsat.smt2 b/test/regress/regress0/nl/coeff-unsat.smt2 new file mode 100644 index 000000000..91e4506da --- /dev/null +++ b/test/regress/regress0/nl/coeff-unsat.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (> a 0)) +(assert (> b 0)) + +(assert (>= a (* 3 b))) + +(assert (< (* a a) (* 8 b b))) + +(check-sat) diff --git a/test/regress/regress0/nl/combine.smt2 b/test/regress/regress0/nl/combine.smt2 new file mode 100644 index 000000000..9c9d839d4 --- /dev/null +++ b/test/regress/regress0/nl/combine.smt2 @@ -0,0 +1,13 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(assert (> c 1)) +(assert (> (* a b) 1)) + +(assert (< (* a b c) 1)) + +(check-sat) diff --git a/test/regress/regress0/nl/disj-eval.smt2 b/test/regress/regress0/nl/disj-eval.smt2 new file mode 100644 index 000000000..717f7a28f --- /dev/null +++ b/test/regress/regress0/nl/disj-eval.smt2 @@ -0,0 +1,14 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NIA) +(set-info :status sat) +(declare-fun x () Int) +(declare-fun y () Int) + +(assert (or (= x 5) (= x 7) (= x 9) (= x 27) (= x 10))) +(assert (or (= y 0) (= y 1) (= y 9) (= y 8))) + + +(assert (= (* x x) (* y y y))) + +(check-sat) diff --git a/test/regress/regress0/nl/dist-big.smt2 b/test/regress/regress0/nl/dist-big.smt2 new file mode 100644 index 000000000..cbd87b085 --- /dev/null +++ b/test/regress/regress0/nl/dist-big.smt2 @@ -0,0 +1,16 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) +(declare-fun v1 () Real) +(declare-fun v2 () Real) +(declare-fun v3 () Real) +(declare-fun v4 () Real) +(declare-fun v5 () Real) +(declare-fun v6 () Real) +(declare-fun v7 () Real) +(declare-fun v8 () Real) + +(assert (= (* (+ v1 v2 v3 v4 v5 v6 v7 v8) (+ v1 v2 v3 v4 v5 v6 v7 v8) (+ v1 v2 v3 v4 v5 v6 v7 v8) (+ v1 v2 v3 v4 v5 v6 v7 v8)) 0)) + +(check-sat) diff --git a/test/regress/regress0/nl/magnitude-wrong-1020-m.smt2 b/test/regress/regress0/nl/magnitude-wrong-1020-m.smt2 new file mode 100644 index 000000000..d0c038d73 --- /dev/null +++ b/test/regress/regress0/nl/magnitude-wrong-1020-m.smt2 @@ -0,0 +1,72 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +From termination analysis of term rewriting. + +Submitted by Harald Roman Zankl + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) + (define-fun x6 () Real + 1.0) + (define-fun x13 () Real + (/ 1.0 32.0)) + (define-fun x3 () Real + 1.0) + (define-fun x10 () Real + 1.0) + (define-fun x0 () Real + 1.0) + (define-fun x17 () Real + 3.0) + (define-fun x7 () Real + (/ 1.0 4.0)) + (define-fun x14 () Real + (/ 3.0 4.0)) + (define-fun x4 () Real + 2.0) + (define-fun x11 () Real + 1.0) + (define-fun x1 () Real + (/ 3.0 2.0)) + (define-fun x18 () Real + 0.0) + (define-fun x8 () Real + 1.0) + (define-fun x15 () Real + 1.0) + (define-fun x5 () Real + 1.0) + (define-fun x12 () Real + 2.0) + (define-fun x2 () Real + 1.0) + (define-fun x9 () Real + 0.0) + (define-fun x16 () Real + (/ 1.0 4.0)) + +(assert (>= x6 0)) +(assert (>= x13 0)) +(assert (>= x3 0)) +(assert (>= x10 0)) +(assert (>= x0 0)) +(assert (>= x17 0)) +(assert (>= x7 0)) +(assert (>= x14 0)) +(assert (>= x4 0)) +(assert (>= x11 0)) +(assert (>= x1 0)) +(assert (>= x18 0)) +(assert (>= x8 0)) +(assert (>= x15 0)) +(assert (>= x5 0)) +(assert (>= x12 0)) +(assert (>= x2 0)) +(assert (>= x9 0)) +(assert (>= x16 0)) +(assert (let ((?v_0 (+ x0 (* x2 x3))) (?v_2 (* x2 x4)) (?v_1 (+ x5 (* x6 x7))) (?v_4 (* x12 x3))) (let ((?v_3 (+ (+ x10 (* x11 x3)) ?v_4)) (?v_6 (* x11 x4)) (?v_7 (* x12 x4)) (?v_5 (+ (+ x10 (* x11 x7)) ?v_4))) (let ((?v_17 (and (and (and (and (and (> ?v_0 x0) (>= ?v_0 x0)) (>= ?v_2 x2)) (and (and (and (> ?v_0 ?v_1) (>= ?v_0 ?v_1)) (>= x1 (* x6 x8))) (>= ?v_2 (* x6 x9)))) (and (and (and (> ?v_3 x0) (>= ?v_3 x0)) (>= ?v_6 x1)) (>= ?v_7 x2))) (and (and (and (> ?v_3 ?v_5) (>= ?v_3 ?v_5)) (>= ?v_6 (* x11 x8))) (>= ?v_7 (+ (* x11 x9) ?v_7))))) (?v_8 (+ x13 (* x14 x3))) (?v_9 (+ x7 (* x9 x15))) (?v_11 (+ x13 (* x14 x7))) (?v_10 (+ x7 (* x9 x3))) (?v_13 (* x18 x3))) (let ((?v_12 (+ (+ x16 (* x17 x15)) ?v_13)) (?v_15 (+ x3 (* x4 (+ (+ x16 (* x17 x7)) ?v_13)))) (?v_14 (+ (+ x16 (* x17 x3)) ?v_13)) (?v_16 (* x18 x4))) (and (and (and (and (and (and ?v_17 (and (and (> ?v_8 0) (>= ?v_8 0)) (>= (* x14 x4) 1))) (and (and (> ?v_9 0) (>= ?v_9 0)) (>= x8 1))) (and (and (and (> ?v_10 ?v_11) (>= ?v_10 ?v_11)) (>= x8 (* x14 x8))) (>= (* x9 x4) (* x14 x9)))) (and (> ?v_12 x15) (>= ?v_12 x15))) (and (and (and (> ?v_14 ?v_15) (>= ?v_14 ?v_15)) (>= (* x17 x4) (* x4 (* x17 x8)))) (>= ?v_16 (* x4 (+ (* x17 x9) ?v_16))))) ?v_17)))))) +(check-sat) diff --git a/test/regress/regress0/nl/metitarski-1025.smt2 b/test/regress/regress0/nl/metitarski-1025.smt2 new file mode 100644 index 000000000..af922a466 --- /dev/null +++ b/test/regress/regress0/nl/metitarski-1025.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoCOSS () Real) +(declare-fun skoSINS () Real) +(declare-fun skoS () Real) +(declare-fun pi () Real) +(assert (and (= (* skoSINS skoSINS) (+ 1 (* skoCOSS (* skoCOSS (- 1))))) (and (not (<= (* pi (/ 1 2)) skoS)) (and (not (<= pi (/ 15707963 5000000))) (and (not (<= (/ 31415927 10000000) pi)) (and (<= 0 skoS) (and (<= 0 skoCOSS) (<= skoSINS skoS)))))))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/metitarski-3-4.smt2 b/test/regress/regress0/nl/metitarski-3-4.smt2 new file mode 100644 index 000000000..2cd913379 --- /dev/null +++ b/test/regress/regress0/nl/metitarski-3-4.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoX () Real) +(declare-fun skoY () Real) +(declare-fun skoZ () Real) +(assert (let ((?v_0 (<= 0 skoY)) (?v_2 (<= (* skoZ (+ (- 1) (* skoY skoX))) (+ skoX skoY))) (?v_1 (* skoX (- 1)))) (let ((?v_3 (* skoX ?v_1))) (let ((?v_4 (* skoY (* skoX (+ (- 3) ?v_3))))) (and (<= (- 1) skoY) (and (not (= skoY 0)) (and (or (not ?v_2) ?v_0) (and (or ?v_0 (<= (* skoZ (+ 1 (* skoY ?v_1))) (+ (+ 1 ?v_1) (* skoY (+ (- 1) ?v_1))))) (and (or (not ?v_0) (or ?v_2 (<= (* skoZ (+ (+ 3 (* skoX skoX)) ?v_4)) (+ (* skoX ?v_3) (* skoY (+ (* skoX (* skoX (- 3))) ?v_4)))))) (and (not (<= skoZ 0)) (and (not (<= skoX (- 1))) (and (not (<= 1 skoY)) (not (<= skoY skoX)))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/metitarski_3_4_2e.smt2 b/test/regress/regress0/nl/metitarski_3_4_2e.smt2 new file mode 100644 index 000000000..d08aef410 --- /dev/null +++ b/test/regress/regress0/nl/metitarski_3_4_2e.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoX () Real) +(declare-fun skoS () Real) +(declare-fun skoC () Real) +(assert (let ((?v_0 (<= skoX 0)) (?v_2 (* skoC (/ 86400000 2025130727)))) (let ((?v_1 (<= ?v_2 skoS))) (and (<= (* skoX (+ (/ (- 69) 2000) (* skoX (/ (- 529) 16000000)))) 12) (and (not ?v_0) (and (or (not (<= (* skoX (+ (+ (+ (/ (- 23) 13) (* skoC (/ 621 8125))) (* skoS (/ (- 46578006721) 26000000000))) (* skoX (+ (+ (/ (- 529) 312000) (* skoC (/ (- 4761) 65000000))) (* skoS (/ 1071294154583 624000000000000)))))) (+ (+ (/ 8000 13) (* skoC (/ 1728 65))) (* skoS (/ (- 2025130727) 3250000))))) ?v_0) (and ?v_1 (and (or (not ?v_1) (not (<= skoS ?v_2))) (and (= (* skoS skoS) (+ 1 (* skoC (* skoC (- 1))))) (and (<= skoX 75) (<= 0 skoX))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/mult-po.smt2 b/test/regress/regress0/nl/mult-po.smt2 new file mode 100644 index 000000000..3f38a7236 --- /dev/null +++ b/test/regress/regress0/nl/mult-po.smt2 @@ -0,0 +1,20 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :status sat) + +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) + +(assert (> a 0)) +(assert (> b 0)) +(assert (> c 0)) +(assert (> d 0)) + +(assert (and (> a b) (> b c) (> c d))) + +(assert (< (* a d) (* b c))) + +(check-sat) diff --git a/test/regress/regress0/nl/nia-wrong-tl.smt2 b/test/regress/regress0/nl/nia-wrong-tl.smt2 new file mode 100644 index 000000000..21055224b --- /dev/null +++ b/test/regress/regress0/nl/nia-wrong-tl.smt2 @@ -0,0 +1,15274 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NIA) +(set-info :status sat) +(set-info :source | + Constraint systems stating that a matrix interpretation is + compatible with a rewriting system (weakly compatible with + all rules, strictly compatible with at least one). + + Contributed by Johannes Waldmann at HTKW Leipzig. + |) +(declare-fun n0 () Int) +(declare-fun n1 () Int) +(declare-fun n2 () Int) +(declare-fun n3 () Int) +(declare-fun n4 () Int) +(declare-fun n5 () Int) +(declare-fun n6 () Int) +(declare-fun n7 () Int) +(declare-fun n8 () Int) +(declare-fun n9 () Int) +(declare-fun n10 () Int) +(declare-fun n11 () Int) +(declare-fun n12 () Int) +(declare-fun n13 () Int) +(declare-fun n14 () Int) +(declare-fun n15 () Int) +(declare-fun n16 () Int) +(declare-fun n17 () Int) +(declare-fun n18 () Int) +(declare-fun n19 () Int) +(declare-fun n20 () Int) +(declare-fun n21 () Int) +(declare-fun n22 () Int) +(declare-fun n23 () Int) +(declare-fun n24 () Int) +(declare-fun n25 () Int) +(declare-fun n26 () Int) +(declare-fun n27 () Int) +(declare-fun n28 () Int) +(declare-fun n29 () Int) +(declare-fun n30 () Int) +(declare-fun n31 () Int) +(declare-fun n32 () Int) +(declare-fun n33 () Int) +(declare-fun n34 () Int) +(declare-fun n35 () Int) +(declare-fun n36 () Int) +(declare-fun n37 () Int) +(declare-fun n38 () Int) +(declare-fun n39 () Int) +(declare-fun n40 () Int) + +;(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ n1 (* (- 1) n7)) 1))) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7))) 0))))) +(check-sat) +(exit) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ n1 (* (- 1) n7)) 1))) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ n1 (* (- 1) n21)) 0))) (not (>= (+ (* n1 n21) (* (- 1) (* n21 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ n1 (* (- 1) n3)) 1))) (>= (+ n5 (* (- 1) (* n1 n5)) (* n3 n5)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ n1 (* (- 1) n3)) 1))) (>= (+ n7 (* (- 1) (* n1 n7)) (* n3 n7)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= n1 n3)) (= (* n1 n5 n7) (* n3 n5 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7) 1) (= n1 n3)) (= (* n1 n7 n7) (* n3 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n12 1) (= n1 n3)) (= (* n1 n12) (* n3 n12))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ n3 (* (- 1) n21)) 1))) (not (>= (+ (* n3 n21) (* (- 1) (* n21 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7 n21) 1) (not (>= (+ n1 (* (- 1) n5)) 0))) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (not (>= (+ n1 (* (- 1) n5)) 0))) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7 n21) 1) (not (>= (+ n3 (* (- 1) n5)) 0))) (not (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n36) 1) (not (>= (+ n3 (* (- 1) n5)) 0))) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (not (>= (+ n3 (* (- 1) n5)) 0))) (not (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7 n21) 1) (= n5 n7)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7 n21) 1) (= n5 n7)) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n36) 1) (= n5 n7)) (= (* n5 n5 n36) (* n5 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (= n5 n7)) (= (* n5 n5 n5 n36) (* n5 n5 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7 n21) 1) (= n5 n7)) (= (* n1 n5 n7 n21) (* n1 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n36) 1) (= n5 n7)) (= (* n1 n5 n36) (* n1 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5) 1) (= n5 n7)) (= (* n1 n5 n5) (* n1 n5 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7 n21) 1) (>= (+ n5 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n36) 1) (>= (+ n5 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n9 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (>= (+ n5 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n9 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ n5 (* (- 1) n12)) 0))) (not (>= (+ (* n5 n21) (* (- 1) (* n12 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5) 1) (not (>= (+ n5 (* (- 1) n12)) 0))) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (>= (+ n5 (* (- 1) n12)) 0))) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n7) 1) (not (>= (+ n5 (* (- 1) n12)) 0))) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7 n21) 1) (= n5 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7 n21) 1) (= n5 n21)) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= n5 n21)) (= (* n5 n21) (* n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= n5 n21)) (= (* n5 n36) (* n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n36) 1) (= n5 n21)) (= (* n5 n5 n36) (* n5 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (= n5 n21)) (= (* n5 n5 n5 n36) (* n5 n5 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7 n21) 1) (= n5 n21)) (= (* n1 n5 n7 n21) (* n1 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n36) 1) (= n5 n21)) (= (* n1 n5 n36) (* n1 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5) 1) (= n5 n21)) (= (* n1 n5 n5) (* n1 n5 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n7) 1) (= n5 n21)) (= (* n3 n5 n7) (* n3 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ n5 (* (- 1) n21)) 1))) (>= (+ n21 (* (- 1) (* n5 n21)) (* n21 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n7) 1) (not (>= (+ n5 (* (- 1) n21)) 1))) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7)) (* n3 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (not (>= (+ n3 (* (- 1) n5)) 1))) (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n5 n5 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (not (>= (+ n1 (* (- 1) n5)) 1))) (>= (+ (* n5 n5 n36) (* (- 1) (* n1 n5 n5 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n7 n21) (* (- 1) (* n5 n7 n21)) (* n7 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7 n21) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n7 n21)) (* n5 n7 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7 n21) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n7 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n21) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n21)) (* n5 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ n36 (* (- 1) (* n5 n36)) (* n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n36) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n36)) (* n5 n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n36) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7 n21) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n7 n21)) (* n1 n7 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n36) 1) (>= (+ n5 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n36)) (* n1 n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (not (>= (+ n1 (* (- 1) n7)) 0))) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n7 n7 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (not (>= (+ n1 (* (- 1) n7)) 0))) (not (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (not (>= (+ n3 (* (- 1) n7)) 0))) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n7 n7 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (not (>= (+ n3 (* (- 1) n7)) 0))) (not (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7 n21) 1) (= n5 n7)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (= n5 n7)) (= (* n5 n7 n36) (* n7 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5 n21) 1) (= n5 n7)) (= (* n1 n5 n5 n21) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n21) 1) (= n5 n7)) (= (* n1 n5 n21) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n5) 1) (= n5 n7)) (= (* n3 n5 n5) (* n3 n5 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n21) 1) (= n5 n7)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (= n5 n7)) (= (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n9 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ n7 (* (- 1) n12)) 0))) (not (>= (+ (* n7 n21) (* (- 1) (* n12 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n21) 1) (not (>= (+ n7 (* (- 1) n12)) 0))) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n12 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (>= (+ n7 (* (- 1) n12)) 0))) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n5) 1) (not (>= (+ n7 (* (- 1) n12)) 0))) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n7) 1) (not (>= (+ n7 (* (- 1) n12)) 0))) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= n7 n21)) (= (* n7 n21) (* n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7 n21) 1) (= n7 n21)) (= (* n7 n7 n7 n21) (* n7 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= n7 n21)) (= (* n7 n36) (* n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (= n7 n21)) (= (* n7 n7 n36) (* n7 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5 n21) 1) (= n7 n21)) (= (* n1 n5 n7 n21) (* n1 n5 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n21) 1) (= n7 n21)) (= (* n1 n7 n21) (* n1 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n5) 1) (= n7 n21)) (= (* n3 n5 n7) (* n3 n5 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n7) 1) (= n7 n21)) (= (* n3 n7 n7) (* n3 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n21) 1) (= n7 n21)) (= (* n5 n5 n7 n21) (* n5 n5 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (= n7 n21)) (= (* n5 n5 n5 n7 n21) (* n5 n5 n5 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (>= n7 2)) (not (>= (+ (* 2 (* n5 n5 n5 n21)) (* (- 1) (* n5 n5 n5 n7 n21))) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ n7 (* (- 1) n21)) 1))) (>= (+ n21 (* (- 1) (* n7 n21)) (* n21 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n5) 1) (not (>= (+ n7 (* (- 1) n21)) 1))) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7)) (* n3 n5 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n3 n7) 1) (not (>= (+ n7 (* (- 1) n21)) 1))) (>= (+ (* n3 n7) (* (- 1) (* n3 n7 n7)) (* n3 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (not (>= (+ n5 (* (- 1) n7)) 1))) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (not (>= (+ n5 (* (- 1) n7)) 1))) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n5 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n21)) (* n7 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7 n21) 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n7 n21)) (* n7 n7 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n36 (* (- 1) (* n7 n36)) (* n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n36) 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n36)) (* n7 n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n21) 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n7 n21)) (* n5 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n21) 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n7 n21)) (* n5 n5 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n21) 1) (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (not (>= (+ n1 (* (- 1) n21)) 0))) (not (>= (+ (* n1 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (not (>= (+ n3 (* (- 1) n21)) 0))) (not (>= (+ (* n3 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5 n7) 1) (= n5 n21)) (= (* n1 n5 n5 n7) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7) 1) (= n5 n21)) (= (* n1 n5 n7) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (= n5 n21)) (= (* n3 n5) (* n3 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (= n5 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (= n5 n21)) (= (* n5 n5 n5 n5 n7) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= n5 n21)) (= (* n5 n5) (* n5 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= n5 n21)) (= (* n5 n7) (* n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7 n7) 1) (= n5 n21)) (= (* n5 n7 n7 n7) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5 n7) 1) (= n7 n21)) (= (* n1 n5 n7 n7) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7) 1) (= n7 n21)) (= (* n1 n7 n7) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (= n7 n21)) (= (* n3 n7) (* n3 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (= n7 n21)) (= (* n5 n5 n7 n7) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (= n7 n21)) (= (* n5 n5 n5 n7 n7) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= n7 n21)) (= (* n5 n7) (* n5 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= n7 n21)) (= (* n7 n7) (* n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7 n7) 1) (= n7 n21)) (= (* n7 n7 n7 n7) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7) 1) (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n1 n12) (* (- 1) (* n1 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (>= n21 2)) (not (>= (+ (* 2 (* n5 n5 n5 n7)) (* (- 1) (* n5 n5 n5 n7 n21))) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (not (>= (+ n7 (* (- 1) n21)) 1))) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5 n7) 1) (not (>= (+ n5 (* (- 1) n21)) 1))) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5 n7) 1) (>= (+ n12 (* (- 1) n21)) 1)) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n7 n12)) (* n1 n5 n7 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7) 1) (>= (+ n12 (* (- 1) n21)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n7 n12)) (* n1 n7 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= (+ n12 (* (- 1) n21)) 1)) (not (>= (+ n1 (* (- 1) (* n1 n12)) (* n1 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (>= (+ n12 (* (- 1) n21)) 1)) (not (>= (+ n5 (* (- 1) (* n5 n12)) (* n5 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (>= (+ n12 (* (- 1) n21)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n12))) 0))) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n12 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= (* n1 n5) (* n1 n7))) (= (* n1 n5 n21) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n21) 1) (= (* n1 n5) (* n1 n7))) (= (* n1 n5 n5 n21) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= (* n1 n7) (* n1 n21))) (= (* n1 n7 n21) (* n1 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n21) 1) (= (* n1 n7) (* n1 n21))) (= (* n1 n5 n7 n21) (* n1 n5 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 1))) (>= (+ n21 (* (- 1) (* n1 n7 n21)) (* n3 n21 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n12))) 0))) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (>= (+ (* n1 n5) (* (- 1) (* n3 n21))) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n21 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (= (* n1 n5) (* n1 n7))) (= (* n1 n5 n7 n21) (* n1 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= (* n1 n5) (* n1 n7))) (= (* n1 n5 n36) (* n1 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n1 n5) (* n1 n7))) (= (* n1 n5 n5) (* n1 n5 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (= (* n1 n5) (* n1 n21))) (= (* n1 n5 n7 n21) (* n1 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= (* n1 n5) (* n1 n21))) (= (* n1 n5 n36) (* n1 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n1 n5) (* n1 n21))) (= (* n1 n5 n5) (* n1 n5 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n21))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n5)) (* n3 n5 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (>= (+ (* n1 n5) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n36 (* (- 1) (* n1 n5 n36)) (* n1 n9 n36)) 1))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n5)) (* n1 n5 n7)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n21))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n5)) (* n1 n5 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n21) (* n7 n21))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5) 1) (= (* n5 n21) (* n7 n21))) (= (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n21) (* n7 n21))) (= (* n1 n5 n21) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n5) 1) (= (* n5 n21) (* n7 n21))) (= (* n1 n5 n5 n21) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n7) 1) (= (* n5 n21) (* n7 n21))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n5) 1) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1))) (>= (+ (* n5 n5 n5) (* (- 2) (* n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n12))) 0))) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n12))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n1 n21) (* n3 n21))) (= (* n1 n5 n7 n21) (* n3 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n1 n21) (* n3 n21))) (= (* n1 n7 n21) (* n3 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n1 n7) (* n1 n21))) (= (* n1 n5 n7 n7) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n1 n7) (* n1 n21))) (= (* n1 n7 n7) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n1 n5) (* n1 n21))) (= (* n1 n5 n5 n7) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n1 n5) (* n1 n21))) (= (* n1 n5 n7) (* n1 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1))) (>= (+ n7 (* (- 1) (* n1 n7 n21)) (* n3 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n36) (* n7 n36))) (= (* n5 n5 n36) (* n5 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n36) (* n7 n36))) (= (* n5 n5 n5 n36) (* n5 n5 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n36) (* n7 n36))) (= (* n1 n5 n36) (* n1 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 0))) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 0))) (not (>= (+ (* n3 n5 n7 n12) (* (- 1) (* n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 0))) (not (>= (+ (* n3 n5 n5 n7 n12) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n21))) 0))) (not (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0))) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n5 n21) (* n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (= (* n5 n21) (* n7 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n1 n7) 1) (= (* n5 n21) (* n7 n21))) (= (* n1 n5 n7 n21) (* n1 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n21))) 0))) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n21))) 1))) (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n21))) 1))) (>= (+ (* n5 n5 n7) (* (- 1) (* n1 n5 n5 n7 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 1))) (>= (+ (* n5 n5 n7) (* (- 1) (* n1 n5 n5 n7 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1))) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n12)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1))) (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n12)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5 n7) 1) (not (>= (+ (* 2 n5) (* (- 1) (* n5 n21))) 1))) (>= (+ (* n5 n5 n7) (* (- 2) (* n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n36) (* n7 n36))) (= (* n5 n7 n36) (* n7 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0))) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n7 n7 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1))) (>= (+ n7 (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n21))) 0))) (not (>= (+ (* n1 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n21))) 0))) (not (>= (+ (* n3 n5 n7 n7 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n5 n5) (* n5 n5 n21))) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n5 n5 n5) (* n5 n5 n21))) (= (* n5 n5 n5 n5 n7) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n21))) 0))) (not (>= (+ (* n3 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n5 n21) (* n5 n7 n7))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n5 n5 n21) (* n5 n7 n7))) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n5 n21) (* n7 n7 n7))) (= (* n5 n5 n7 n21) (* n7 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n5 n5 n21) (* n7 n7 n7))) (= (* n5 n5 n5 n7 n21) (* n5 n7 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n5 n21) (* n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n5 n5 n21) (* n5 n7 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (= (* n5 n5 n21) (* n7 n7 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n21))) 0))) (not (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n21))) 1))) (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1))) (>= (+ n7 (* (- 1) (* n5 n5 n5 n7)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1))) (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n21))) 1))) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n7 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n7) 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n21))) 1))) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n7 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n3 n7 n7 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (= (* n5 n5 n5) (* n5 n5 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= (* n5 n5 n5) (* n5 n5 n21))) (= (* n5 n5 n5 n36) (* n5 n5 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n3 n5 n7 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (= (* n5 n5 n5) (* n5 n7 n7))) (= (* n5 n5 n5 n7 n21) (* n5 n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= (* n5 n5 n5) (* n5 n7 n7))) (= (* n5 n5 n5 n36) (* n5 n7 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (= (* n5 n5 n5) (* n5 n7 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n7 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= (* n5 n5 n5) (* n5 n7 n21))) (= (* n5 n5 n5 n36) (* n5 n7 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (= (* n5 n5 n5) (* n7 n7 n21))) (= (* n5 n5 n5 n7 n21) (* n7 n7 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (= (* n5 n5 n5) (* n7 n7 n21))) (= (* n5 n5 n5 n36) (* n7 n7 n21 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 0))) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ (* n7 n21) (* (- 1) (* n1 n7 n21 n36)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ n36 (* (- 1) (* n1 n36 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ (* n7 n21) (* (- 1) (* n3 n7 n7 n7 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ n36 (* (- 1) (* n3 n7 n7 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ (* n7 n21) (* (- 1) (* n1 n7 n7 n21 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ n36 (* (- 1) (* n1 n7 n21 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n7 n21) 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n7 n7 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n36 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5))) 1))) (>= (+ n36 (* (- 1) (* n3 n5 n7 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= (* n5 n5 n21) (* n7 n7 n7))) (= (* n5 n5 n21 n21) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= (* n5 n7 n7) (* n7 n7 n7))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= (* n5 n7 n21) (* n7 n7 n7))) (= (* n5 n7 n21 n21) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (= (* n7 n7 n7) (* n7 n7 n21))) (= (* n7 n7 n7 n21) (* n7 n7 n21 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n1 n36) (* (- 1) (* n7 n7 n7))) 0))) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7))) 1))) (>= (+ n21 (* (- 1) (* n5 n7 n21 n21)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7))) 1))) (>= (+ n21 (* (- 1) (* n5 n5 n21 n21)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n1 n36) (* (- 1) (* n7 n7 n7))) 1))) (>= (+ n21 (* (- 1) (* n1 n21 n36)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1))) (>= (+ n21 (* (- 1) (* n5 n5 n5 n21)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n21 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n7))) 1))) (>= (+ n21 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n7 n21))) 0))) (not (>= (+ (* n1 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n7 n21))) 0))) (not (>= (+ (* n3 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n5 n21) (* n5 n7 n21))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n5 n21) (* n5 n7 n21))) (= (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n5 n21) (* n5 n7 n21))) (= (* n1 n5 n5 n21) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n5 n5) (* n5 n7 n21))) (= (* n5 n5 n5 n5) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n5 n5) (* n5 n7 n21))) (= (* n5 n5 n5 n5 n5) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n5 n5) (* n5 n7 n21))) (= (* n1 n5 n5 n5) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n7 n21))) 0))) (not (>= (+ (* n3 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n7 n7) (* n5 n7 n21))) (= (* n5 n5 n7 n7) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n7 n7) (* n5 n7 n21))) (= (* n5 n5 n5 n7 n7) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n7 n7) (* n5 n7 n21))) (= (* n1 n5 n7 n7) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n7 n21) (* n7 n7 n7))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n7 n21) (* n7 n7 n7))) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n7 n21) (* n7 n7 n7))) (= (* n1 n5 n7 n21) (* n1 n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n7 n21) (* n7 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (= (* n5 n7 n21) (* n7 n7 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (= (* n5 n7 n21) (* n7 n7 n21))) (= (* n1 n5 n7 n21) (* n1 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n7 n21))) 0))) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ n5 (* (- 1) (* n5 n5 n5 n21)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n5 n5 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n5)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7))) 1))) (>= (+ n1 (* (- 1) (* n1 n5 n7 n21)) (* n1 n7 n7 n7)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ n5 (* (- 1) (* n5 n5 n5 n5)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n5 n5 n5)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ n5 (* (- 1) (* n5 n5 n7 n7)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n5 n7 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n7 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n7 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= (* n5 n5) 1) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n7 n21))) 1))) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n21))) 1))) (>= (+ n1 (* (- 1) (* n1 n5 n7 n21)) (* n1 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n5 n36) (* n7 n7 n36))) (= (* n5 n5 n5 n36) (* n5 n7 n7 n36))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n5 n5 n36))) 0))) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n5 n5 n5 n36))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n5 n5 n36))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n5 n36)) (* n5 n5 n5 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n5 n5) (* n7 n7 n21))) (= (* n5 n5 n5 n7) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n7 n7) (* n7 n7 n21))) (= (* n5 n7 n7 n7) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n7 n7 n7) (* n7 n7 n21))) (= (* n7 n7 n7 n7) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= (* n5 n7 n21) (* n7 n7 n21))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n21))) 1))) (>= (+ n7 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21))))) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n21))) 1))) (>= (+ n7 (* (- 1) (* n5 n5 n5 n7)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n21))) 1))) (>= (+ n7 (* (- 1) (* n7 n7 n7 n7)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n21))) 1))) (>= (+ n7 (* (- 1) (* n5 n7 n7 n7)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n1 n5 n5) (* n1 n7 n21))) (= (* n1 n5 n5 n5) (* n1 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n1 n7 n21) (* n3 n7 n7))) (= (* n1 n5 n7 n21) (* n3 n5 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n1 n7 n21) (* n3 n5 n7))) (= (* n1 n5 n7 n21) (* n3 n5 n5 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n7))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n7 n21)) (* n3 n5 n7 n7)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n7 n21)) (* n3 n5 n5 n7)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= (* n5 n5 n7 n21) (* n7 n7 n7 n21))) (= (* n5 n5 n5 n7 n21) (* n5 n7 n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n7 n21))) 0))) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n7 n21))) 0))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n7 n21))) 1))) (>= (+ n5 (* (- 1) (* n1 n5 n5 n7 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21)))) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n7 n21) (* n21 n21)) (= (* n5 n21) (* n21 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n5 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n36) (* n7 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= n9 2) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n5 (* (- 1) n7)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n5 (* (- 1) n21)) 0) (not (>= (+ n5 (* (- 1) n21)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n12 (* (- 1) n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= n7 n21) (>= n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n5 (* (- 1) n7)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n5 (* (- 1) n21)) 0) (not (>= (+ n5 (* (- 1) n21)) 1)) (not (= n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n5 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= n9 2) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7) (* n5 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n9 1) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n5 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n21) (* n21 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n7 n21) (* n21 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= n7 n21) (>= (+ n5 (* (- 1) n7)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n5 n21) (not (>= (+ n5 (* (- 1) n21)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n7 n7) (* n7 n7 n7)) (>= (* n5 n7 n7) (* n7 n7 n7))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n7) (- 1)) (>= (* n5 n5 n5) 2) (= (* n5 n7 n7) (* (- 1) (* n7 n7 n7))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n7) (- 1)) (= (* n5 n7 n7) (* (- 1) (* n7 n7 n7))) (>= (* n7 n7 n7) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n7) (- 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 1) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7 n7) (* (- 1) (* n7 n7 n7))) (not (>= (+ n7 (* (- 1) (* n7 n7 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n7 n7) (* (- 1) (* n7 n7 n7))) (>= (* n5 n7 n7) (* (- 1) (* n7 n7 n7)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n5 (* (- 1) n9)) 1) (>= (+ n5 (* (- 1) n7)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n7 (* (- 1) n9)) 0) (not (>= (+ n7 (* (- 1) n9)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n3)) 1)) (>= n1 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n3 (* (- 1) (* n3 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (= (* n1 n21) (* n3 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7))) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5) (* n1 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7))) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5) (* n3 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n7) (* n3 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n1 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n21) (* n3 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n15 (* (- 1) n18) (* n3 n12)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n3 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ n1 (* (- 1) n3)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (>= n1 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n3) (* (- 1) (* n3 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 1) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n1) (* (- 1) (* n1 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n1 n21) (* n3 n21)) (>= n1 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n1 (* (- 1) (* n1 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 (- 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n1 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (= (* n1 n21) (* n3 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n21) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5) (* n1 n7)) (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 (- 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (>= n1 2) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n7) (* (- 1) (* n1 n9))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n1 n7) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7))) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5) (* n1 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n7) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5) (* (- 1) (* n1 n9))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n1 n5) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n21) (* n3 n21)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= n36 2)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= n1 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n21 (* (- 1) (* n1 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n21 (* (- 1) (* n3 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n7 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= n1 1) (not (>= (+ n1 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n9 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n5 n21) (* n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n5) (* (- 1) (* n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n5 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 (- 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n5 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (* n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 (- 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n36 2)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= n1 (- 1)) (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n1 n5) (* n1 n7)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5))) 0)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (* n5 n5) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n5 n5) (* n5 n7 n21)) (>= (* n5 n5 n5) (* n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n21))) 0) (not (= (* n5 n5 n5) (* n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (= (* n5 n5 n5) (* (- 1) (* n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n7 n7 n7) (* n7 n7 n21)) (>= (* n7 n7 n7) (* n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n21))) 0) (not (= (* n7 n7 n7) (* n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (= (* n7 n7 n7) (* (- 1) (* n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n1 n5 n5) (* n1 n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n5 n5 n5) (* n5 n7 n7)) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 1)) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n7 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 1)) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n1 n5 n5) (* n1 n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n1 n5 n5) (* n1 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5))) 1) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n5))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n5))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 1) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n36 (* (- 1) (* n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n36 (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n36 (* n1 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n1 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n5 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n7 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n1 n5 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 1) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 0) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n1 n5 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* 7 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n1 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n1 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n3 n5 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n5 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n5 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n7 n7 n36) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 1) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n1 n5 n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ n5 (* (- 1) n7)) 0) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n5 (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n21) (* n3 n21)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= n1 2) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n21) (* n3 n21)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= n1 2) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n5 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n7 n21) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n7 n21) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 1) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n5 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (= (* n1 n5) (* n1 n7)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n7 n7 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 1) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n21) (* n3 n21)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= n36 (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n36 (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= n1 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n21 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= n1 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= n1 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n36)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0) (not (= (* n5 n5 n36) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* (- 1) (* n5 n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n1 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n5 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n3)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n3 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n9 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n9 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n21 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n1 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n1 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n1 (* n1 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n3 n12))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n7 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n5 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n5 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n5 (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n5 n5) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n7 n7 n7) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n5 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n5 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n5 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n5 (* n5 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* 2 (* n7 n21)) (* (- 1) (* n1 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n3 n5 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n36 (* n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n36 (* n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n21 (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n1 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n21 (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n5 (* n5 n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n5 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n5 n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n5 n7 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n7 n7) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n7 n7 n21) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n7 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n3 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n3 n5 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (= (* n1 n5 n5) (* n1 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n7 n21) (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (* n1 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n5 n21) (* (- 1) (* n1 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n1 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (= (* n3 n7 n7) 0)) (>= (* n3 n7 n7) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n7 (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) (* n3 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n3)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ n3 (* (- 1) (* n1 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n3 n5 n7) (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n3 n5 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n3 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (= (* n1 n5 n5) 0)) (>= (* n1 n5 n5) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 0) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n5) (* n1 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5))) 1) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (>= n1 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* 2 (* n1 n7)) (* (- 1) (* n1 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n5 n7) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n1 n5 n5) (* n1 n5 n7)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 (- 1)) (= (* n5 n7) (* n7 n21)) (= (* n1 n5 n5) (* n1 n7 n21)) (not (>= (+ (* 2 (* n7 n21)) (* (- 1) (* n1 n7 n21))) 1)) (not (>= (* n1 n5 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (* n5 n5 n5 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (= (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n5 n21)) (* n5 n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n5))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n5))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (= (* n5 n5 n5) (* n5 n7 n7)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ (* n1 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n7 n7) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (= (* n1 n21) (* n3 n21)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n36) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n9)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n36 (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n21 (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n21 (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n5 (* n5 n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n5 n21) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n5 n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n5 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n7 n7 n21) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n7 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n3 n12) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n7 n36) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n1 n5 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n1 n5 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* 7 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n36 (* n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n36 (* n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n21) (* n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n36) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n36) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n7 n21) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n5 n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n36 (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n5 n7 n7) (* n5 n5 n5 n7 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n7)) (* n5 n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n5 n5 n7) (* n5 n5 n5 n7 n21)) (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n5 n7)) (* n5 n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n7 n7 n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n5 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (>= (* n5 n5 n5 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n7 n21) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n7 n21) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n5 n21)) (* n5 n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n7 n7 n36) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n5 n36) 1) (not (= (* n5 n5 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 2) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n7 n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 2) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n5 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n5 n7) (* n5 n5 n7 n21)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n5 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n7) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n5 (* n5 n5 n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n7 n7 n7) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n5 n5) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n5) (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n5 (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 (* n5 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n5) (* n5 n7 n7)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 0) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n7 n7) (* n7 n7 n7)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n5) (* n5 n7 n7)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n5 n7 n7) (- 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n1 n5 n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n1 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n36 (* n1 n5 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 1) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n1 n5 n36) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n5 n36) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (>= n1 1) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n5 (* (- 1) n7)) 0) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n5 (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n7 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n36 (* (- 1) (* n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= n36 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n36) (* n7 n36)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n21 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n9 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n9 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n3)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n3 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n5 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n7 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n5 (* (- 1) n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (>= n1 2) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (>= (+ n1 (* (- 1) n3)) 0) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n3 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n1 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* (- 1) (* n5 n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0) (not (= (* n5 n5 n36) (* n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n36)) (* n5 n5 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n21 (* (- 1) n36)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (= (* n5 n7) (* n5 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n36 (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* 7 n36) (* (- 1) (* n1 n36))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n36 (* n1 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (* n1 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ n1 (* n1 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ n1 (* (- 1) (* n1 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n36))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* n3 n12)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (= (* n1 n5) (* n1 n7)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ n18 (* (- 1) n33)) 1)) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n7 n21)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n36))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n21)) (* n5 n5 n5 n9 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (not (>= (+ n7 (* (- 1) n9)) 1)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (>= (+ (* n1 n36) (* (- 1) (* n3 n12))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n9 n36))) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (not (>= (+ n7 (* (- 1) n9)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n36)) (* n7 n9 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* 2 (* n7 n21)) (* (- 1) (* n1 n7 n21))) 1)) (= (* n1 n5 n21) (* n1 n7 n21)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 1) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (* n1 n5 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n9 n36))) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n5 n5))) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n1 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)) (not (>= (+ (* 2 (* n5 n36)) (* (- 1) (* n1 n5 n36))) 1)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n7 n7 n7 n21))) 0)) (= (* n1 n5 n36) (* n1 n21 n36)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n9 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (= n5 0)) (>= n36 1)) (>= (* n1 n5 n5 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n5 1) (>= n7 1)) (>= (* n3 n5 n5 n5 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (not (= n5 0)) (not (= n7 0))) (>= (* n3 n5 n5 n7 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (= n5 0))) (>= (* n1 n5 n5 n5 n5) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n5 1) (>= n7 1) (>= n36 1)) (>= (* n3 n5 n7 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n5 1) (not (= n7 0)) (>= n21 1)) (>= (* n3 n5 n7 n7 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= n7 1) (>= n21 1) (>= n36 1)) (>= (* n1 n7 n21 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (= n7 0)) (not (= n21 0))) (>= (* n1 n7 n7 n21 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (not (= n7 0)) (>= n36 1)) (>= (* n3 n7 n7 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (not (= n36 0))) (>= (* n1 n36 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (>= n36 1)) (>= (* n7 n7 n7 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (not (= n7 0)) (>= n21 1)) (>= (* n7 n7 n7 n7 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n5 1) (>= n7 1)) (>= (* n3 n5 n7 n7 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= n5 1) (>= n7 1)) (>= (* n1 n5 n5 n5 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= n5 1) (not (= n7 0)) (>= n21 1)) (>= (* n1 n5 n7 n7 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (not (= n5 0)) (>= n7 1)) (>= (* n5 n5 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n5 1) (>= n7 1) (>= n12 1)) (>= (* n3 n5 n7 n12) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= n9 1) (>= n36 1)) (>= (* n1 n9 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n21 1) (>= n36 1)) (>= (* n3 n21 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (not (= n5 0)) (>= n9 1) (>= n21 1)) (>= (* n5 n5 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (>= n9 1) (>= n21 1)) (>= (* n5 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n9 1) (>= n36 1)) (>= (* n9 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (not (= n7 0)) (>= n9 1) (>= n21 1)) (>= (* n7 n7 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n7 1) (>= n9 1) (>= n21 1)) (>= (* n7 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (not (= n21 0))) (>= (* n5 n5 n5 n21 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n5 1) (>= n21 1)) (>= (* n3 n5 n5 n5 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (>= n7 1) (>= n36 1)) (>= (* n3 n7 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= n5 1) (>= n21 1)) (>= (* n1 n5 n5 n5 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n1 1) (>= n7 1) (>= n9 1) (>= n21 1)) (>= (* n1 n7 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (>= n9 1) (>= n36 1)) (>= (* n5 n9 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (not (= n5 0)) (>= n7 1) (>= n9 1) (>= n21 1)) (>= (* n5 n5 n7 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n5 1) (>= n7 1) (>= n9 1) (>= n21 1)) (>= (* n5 n7 n9 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (>= n3 1) (not (= n5 0)) (>= n36 1)) (>= (* n3 n5 n5 n36) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n1 (* (- 1) n3)) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (>= n1 2) (not (>= (+ n3 (* (- 1) (* n3 n12)) (* n3 n21)) 1)) (>= (+ (* n3 n21) (* (- 1) (* n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (= (* n1 n21) (* n3 n21)) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n3)) 1)) (not (>= (+ n3 (* (- 1) (* n3 n12)) (* n3 n21)) 1)) (>= n1 1) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (= (* n1 n5) (* n1 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (= (* n1 n5) (* n1 n7)) (not (>= (+ n1 (* (- 1) n3)) 1)) (not (>= (+ n3 (* (- 1) (* n3 n12)) (* n3 n21)) 1)) (>= n1 1) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (= (* n1 n5) (* n1 n7)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n12))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n12))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n12) (* n3 n12)) (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n12))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7) (* n5 n21)) (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7) (* (- 1) (* n5 n21))) 0) (= (* n1 n5) (* n1 n7)) (= (* n5 n7) (* n5 n21)) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (>= n1 2) (not (>= (+ n3 (* (- 1) (* n3 n12)) (* n3 n21)) 1)) (not (>= (+ n1 (* (- 1) n3)) 1)) (>= (+ (* n1 n21) (* (- 1) (* n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (>= (* n1 n5 n5 n36) 2) (not (>= (* n1 n5 n5 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (>= (* n3 n5 n5 n5 n7) 2) (not (>= (* n3 n5 n5 n5 n7) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (>= (* n3 n5 n5 n7 n7) 2) (not (>= (* n3 n5 n5 n7 n7) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (>= (* n1 n5 n5 n5 n5) 2) (not (>= (* n1 n5 n5 n5 n5) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (>= (* n3 n5 n7 n36) 2) (not (>= (* n3 n5 n7 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (>= (* n3 n5 n7 n7 n21) 2) (not (>= (* n3 n5 n7 n7 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (>= (* n1 n7 n21 n36) 2) (not (>= (* n1 n7 n21 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (>= (* n1 n7 n7 n21 n21) 2) (not (>= (* n1 n7 n7 n21 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (>= (* n3 n7 n7 n36) 2) (not (>= (* n3 n7 n7 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (>= (* n1 n36 n36) 2) (not (>= (* n1 n36 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (>= (* n7 n7 n7 n36) 2) (not (>= (* n7 n7 n7 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (>= (* n7 n7 n7 n7 n21) 2) (not (>= (* n7 n7 n7 n7 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (>= (* n3 n5 n7 n7 n7) 2) (not (>= (* n3 n5 n7 n7 n7) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (>= (* n1 n5 n5 n5 n7) 2) (not (>= (* n1 n5 n5 n5 n7) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (>= (* n1 n5 n7 n7 n21) 2) (not (>= (* n1 n5 n7 n7 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (>= (* n5 n5 n7) 2) (not (>= (* n5 n5 n7) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (>= (* n3 n5 n7 n12) 2) (not (>= (* n3 n5 n7 n12) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (>= (* n1 n9 n36) 2) (not (>= (* n1 n9 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (>= (* n3 n21 n36) 2) (not (>= (* n3 n21 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (>= (* n5 n5 n9 n21) 2) (not (>= (* n5 n5 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (>= (* n5 n9 n21) 2) (not (>= (* n5 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n9 0))) (ite (>= (* n9 n36) 0) (>= (* n9 n36) 2) (not (>= (* n9 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (>= (* n7 n7 n9 n21) 2) (not (>= (* n7 n7 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (>= (* n7 n9 n21) 2) (not (>= (* n7 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (>= (* n5 n5 n5 n21 n21) 2) (not (>= (* n5 n5 n5 n21 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (>= (* n3 n5 n5 n5 n21) 2) (not (>= (* n3 n5 n5 n5 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (>= (* n3 n7 n36) 2) (not (>= (* n3 n7 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (>= (* n1 n5 n5 n5 n21) 2) (not (>= (* n1 n5 n5 n5 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (>= (* n1 n7 n9 n21) 2) (not (>= (* n1 n7 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (>= (* n5 n9 n36) 2) (not (>= (* n5 n9 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (>= (* n5 n5 n7 n9 n21) 2) (not (>= (* n5 n5 n7 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (>= (* n5 n7 n9 n21) 2) (not (>= (* n5 n7 n9 n21) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (>= (* n3 n5 n5 n36) 2) (not (>= (* n3 n5 n5 n36) (- 1))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n5 n5 n7 n7) (- 1))) (>= (* n3 n5 n5 n7 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 2) (= (* n5 n36) (* n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= n12 2)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n5 n7 n7 n7) 0)) (>= (* n3 n5 n7 n7 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n5 n7 n12) (- 1))) (>= (* n3 n5 n7 n12) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n5 n5 n5 n7) 0)) (>= (* n3 n5 n5 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n12 (- 1))) (>= n12 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n5 n7) (- 1))) (>= (* n5 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n1 n5 n5 n5 n7) (- 1))) (>= (* n1 n5 n5 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n5 n7 n7 n7) (- 1))) (>= (* n3 n5 n7 n7 n7) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n1 n5 n5 n5 n5) (- 1))) (>= (* n1 n5 n5 n5 n5) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n5 n5 n5 n7) (- 1))) (>= (* n3 n5 n5 n5 n7) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ n1 (* n1 n5 n5 n36)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n5 n5 n36)) 0)) (>= (+ n1 (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ n5 (* n1 n5 n5 n36)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n1 n5 n5 n36)) 0)) (>= (+ n5 (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ n36 (* n1 n5 n5 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n1 n5 n5 n36)) 0)) (>= (+ n36 (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ n3 (* n3 n5 n5 n5 n7)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n5 n5 n7)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ n5 (* n3 n5 n5 n5 n7)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n5 n5 n7)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ n7 (* n3 n5 n5 n5 n7)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n5 n5 n5 n7)) 0)) (>= (+ n7 (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ n3 (* n3 n5 n5 n7 n7)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n5 n7 n7)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ n5 (* n3 n5 n5 n7 n7)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n5 n7 n7)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ n7 (* n3 n5 n5 n7 n7)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n5 n5 n7 n7)) 0)) (>= (+ n7 (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ n1 (* n1 n5 n5 n5 n5)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n5 n5 n5 n5)) 0)) (>= (+ n1 (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ n5 (* n1 n5 n5 n5 n5)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n1 n5 n5 n5 n5)) 0)) (>= (+ n5 (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ n3 (* n3 n5 n7 n36)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n7 n36)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ n5 (* n3 n5 n7 n36)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n7 n36)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ n7 (* n3 n5 n7 n36)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n5 n7 n36)) 0)) (>= (+ n7 (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ n36 (* n3 n5 n7 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n3 n5 n7 n36)) 0)) (>= (+ n36 (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ n3 (* n3 n5 n7 n7 n21)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n7 n7 n21)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ n5 (* n3 n5 n7 n7 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n7 n7 n21)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ n7 (* n3 n5 n7 n7 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n5 n7 n7 n21)) 0)) (>= (+ n7 (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ n21 (* n3 n5 n7 n7 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n3 n5 n7 n7 n21)) 0)) (>= (+ n21 (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ n1 (* n1 n7 n21 n36)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n7 n21 n36)) 0)) (>= (+ n1 (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ n7 (* n1 n7 n21 n36)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n1 n7 n21 n36)) 0)) (>= (+ n7 (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ n21 (* n1 n7 n21 n36)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n1 n7 n21 n36)) 0)) (>= (+ n21 (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ n36 (* n1 n7 n21 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n1 n7 n21 n36)) 0)) (>= (+ n36 (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ n1 (* n1 n7 n7 n21 n21)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n7 n7 n21 n21)) 0)) (>= (+ n1 (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ n7 (* n1 n7 n7 n21 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n1 n7 n7 n21 n21)) 0)) (>= (+ n7 (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ n21 (* n1 n7 n7 n21 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n1 n7 n7 n21 n21)) 0)) (>= (+ n21 (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ n3 (* n3 n7 n7 n36)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n7 n7 n36)) 0)) (>= (+ n3 (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ n7 (* n3 n7 n7 n36)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n7 n7 n36)) 0)) (>= (+ n7 (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ n36 (* n3 n7 n7 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n3 n7 n7 n36)) 0)) (>= (+ n36 (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n36 n36))) 0)) (>= (+ n1 (* n1 n36 n36)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n36 n36)) 0)) (>= (+ n1 (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n1 n36 n36))) 0)) (>= (+ n36 (* n1 n36 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n1 n36 n36)) 0)) (>= (+ n36 (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ n7 (* n7 n7 n7 n36)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n7 n7 n7 n36)) 0)) (>= (+ n7 (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ n36 (* n7 n7 n7 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n7 n7 n7 n36)) 0)) (>= (+ n36 (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ n7 (* n7 n7 n7 n7 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n7 n7 n7 n7 n21)) 0)) (>= (+ n7 (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ n21 (* n7 n7 n7 n7 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n7 n7 n7 n7 n21)) 0)) (>= (+ n21 (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ n3 (* n3 n5 n7 n7 n7)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n7 n7 n7)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ n5 (* n3 n5 n7 n7 n7)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n7 n7 n7)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ n7 (* n3 n5 n7 n7 n7)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n5 n7 n7 n7)) 0)) (>= (+ n7 (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ n1 (* n1 n5 n5 n5 n7)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n5 n5 n5 n7)) 0)) (>= (+ n1 (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ n5 (* n1 n5 n5 n5 n7)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n1 n5 n5 n5 n7)) 0)) (>= (+ n5 (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ n7 (* n1 n5 n5 n5 n7)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n1 n5 n5 n5 n7)) 0)) (>= (+ n7 (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ n1 (* n1 n5 n7 n7 n21)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n5 n7 n7 n21)) 0)) (>= (+ n1 (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ n5 (* n1 n5 n7 n7 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n1 n5 n7 n7 n21)) 0)) (>= (+ n5 (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ n7 (* n1 n5 n7 n7 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n1 n5 n7 n7 n21)) 0)) (>= (+ n7 (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ n21 (* n1 n5 n7 n7 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n1 n5 n7 n7 n21)) 0)) (>= (+ n21 (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n5 n7))) 0)) (>= (+ n5 (* n5 n5 n7)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n5 n7)) 0)) (>= (+ n5 (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n5 n5 n7))) 0)) (>= (+ n7 (* n5 n5 n7)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n5 n5 n7)) 0)) (>= (+ n7 (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ n3 (* n3 n5 n7 n12)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n7 n12)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ n5 (* n3 n5 n7 n12)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n7 n12)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ n7 (* n3 n5 n7 n12)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n5 n7 n12)) 0)) (>= (+ n7 (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ n12 (* n3 n5 n7 n12)) 1)) (ite (>= n12 0) (not (>= (+ n12 (* n3 n5 n7 n12)) 0)) (>= (+ n12 (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n9 n36))) 0)) (>= (+ n1 (* n1 n9 n36)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n9 n36)) 0)) (>= (+ n1 (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n1 n9 n36))) 0)) (>= (+ n9 (* n1 n9 n36)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n1 n9 n36)) 0)) (>= (+ n9 (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n1 n9 n36))) 0)) (>= (+ n36 (* n1 n9 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n1 n9 n36)) 0)) (>= (+ n36 (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n21 n36))) 0)) (>= (+ n3 (* n3 n21 n36)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n21 n36)) 0)) (>= (+ n3 (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n3 n21 n36))) 0)) (>= (+ n21 (* n3 n21 n36)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n3 n21 n36)) 0)) (>= (+ n21 (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n3 n21 n36))) 0)) (>= (+ n36 (* n3 n21 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n3 n21 n36)) 0)) (>= (+ n36 (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ n5 (* n5 n5 n9 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n5 n9 n21)) 0)) (>= (+ n5 (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ n9 (* n5 n5 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n5 n5 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ n21 (* n5 n5 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n5 n5 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n9 n21))) 0)) (>= (+ n5 (* n5 n9 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n9 n21)) 0)) (>= (+ n5 (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n5 n9 n21))) 0)) (>= (+ n9 (* n5 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n5 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n5 n9 n21))) 0)) (>= (+ n21 (* n5 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n5 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n9 0))) (ite (>= (* n9 n36) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n9 n36))) 0)) (>= (+ n9 (* n9 n36)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n9 n36)) 0)) (>= (+ n9 (* (- 1) (* n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n9 0))) (ite (>= (* n9 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n9 n36))) 0)) (>= (+ n36 (* n9 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n9 n36)) 0)) (>= (+ n36 (* (- 1) (* n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ n7 (* n7 n7 n9 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n7 n7 n9 n21)) 0)) (>= (+ n7 (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ n9 (* n7 n7 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n7 n7 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ n21 (* n7 n7 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n7 n7 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n7 n9 n21))) 0)) (>= (+ n7 (* n7 n9 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n7 n9 n21)) 0)) (>= (+ n7 (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n7 n9 n21))) 0)) (>= (+ n9 (* n7 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n7 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n7 n9 n21))) 0)) (>= (+ n21 (* n7 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n7 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ n5 (* n5 n5 n5 n21 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n5 n5 n21 n21)) 0)) (>= (+ n5 (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ n21 (* n5 n5 n5 n21 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n5 n5 n5 n21 n21)) 0)) (>= (+ n21 (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ n3 (* n3 n5 n5 n5 n21)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n5 n5 n21)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ n5 (* n3 n5 n5 n5 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n5 n5 n21)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ n21 (* n3 n5 n5 n5 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n3 n5 n5 n5 n21)) 0)) (>= (+ n21 (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n7 n36))) 0)) (>= (+ n3 (* n3 n7 n36)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n7 n36)) 0)) (>= (+ n3 (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n3 n7 n36))) 0)) (>= (+ n7 (* n3 n7 n36)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n3 n7 n36)) 0)) (>= (+ n7 (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n3 n7 n36))) 0)) (>= (+ n36 (* n3 n7 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n3 n7 n36)) 0)) (>= (+ n36 (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ n1 (* n1 n5 n5 n5 n21)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n5 n5 n5 n21)) 0)) (>= (+ n1 (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ n5 (* n1 n5 n5 n5 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n1 n5 n5 n5 n21)) 0)) (>= (+ n5 (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ n21 (* n1 n5 n5 n5 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n1 n5 n5 n5 n21)) 0)) (>= (+ n21 (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ n1 (* n1 n7 n9 n21)) 1)) (ite (>= n1 0) (not (>= (+ n1 (* n1 n7 n9 n21)) 0)) (>= (+ n1 (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ n7 (* n1 n7 n9 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n1 n7 n9 n21)) 0)) (>= (+ n7 (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ n9 (* n1 n7 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n1 n7 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ n21 (* n1 n7 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n1 n7 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n9 n36))) 0)) (>= (+ n5 (* n5 n9 n36)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n9 n36)) 0)) (>= (+ n5 (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n5 n9 n36))) 0)) (>= (+ n9 (* n5 n9 n36)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n5 n9 n36)) 0)) (>= (+ n9 (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n5 n9 n36))) 0)) (>= (+ n36 (* n5 n9 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n5 n9 n36)) 0)) (>= (+ n36 (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ n5 (* n5 n5 n7 n9 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n5 n7 n9 n21)) 0)) (>= (+ n5 (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ n7 (* n5 n5 n7 n9 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n5 n5 n7 n9 n21)) 0)) (>= (+ n7 (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ n9 (* n5 n5 n7 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n5 n5 n7 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ n21 (* n5 n5 n7 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n5 n5 n7 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ n5 (* n5 n7 n9 n21)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n5 n7 n9 n21)) 0)) (>= (+ n5 (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ n7 (* n5 n7 n9 n21)) 1)) (ite (>= n7 0) (not (>= (+ n7 (* n5 n7 n9 n21)) 0)) (>= (+ n7 (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ n9 (* n5 n7 n9 n21)) 1)) (ite (>= n9 0) (not (>= (+ n9 (* n5 n7 n9 n21)) 0)) (>= (+ n9 (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ n21 (* n5 n7 n9 n21)) 1)) (ite (>= n21 0) (not (>= (+ n21 (* n5 n7 n9 n21)) 0)) (>= (+ n21 (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ n3 (* n3 n5 n5 n36)) 1)) (ite (>= n3 0) (not (>= (+ n3 (* n3 n5 n5 n36)) 0)) (>= (+ n3 (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ n5 (* n3 n5 n5 n36)) 1)) (ite (>= n5 0) (not (>= (+ n5 (* n3 n5 n5 n36)) 0)) (>= (+ n5 (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= n36 0) (not (>= (+ n36 (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ n36 (* n3 n5 n5 n36)) 1)) (ite (>= n36 0) (not (>= (+ n36 (* n3 n5 n5 n36)) 0)) (>= (+ n36 (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n1 2) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n21 (* (- 1) (* n1 n7 n9 n21))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ n1 (* n1 n7 n9 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n1 2) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n21 (* (- 1) (* n1 n5 n5 n5 n21))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ n1 (* n1 n5 n5 n5 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n9)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n3)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n21 (* (- 1) (* n3 n5 n5 n5 n21))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ n3 (* n3 n5 n5 n5 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n3 n12) (* (- 1) (* n5 n21))) 1)) (not (>= (+ n36 (* (- 1) (* n3 n21 n36))) 1)) (>= (+ n12 (* (- 1) n21)) 1) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n7) (* n5 n21)) (= (* n5 n7) (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n21 (* n3 n21 n36)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n9)) 1)) (>= n1 2) (not (>= (+ n1 (* (- 1) n3)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (not (>= (+ n12 (* (- 1) (* n3 n5 n7 n12))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ n3 (* n3 n5 n7 n12)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n1 2) (not (>= (+ n7 (* (- 1) n9)) 1)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n21 (* (- 1) (* n1 n7 n7 n21 n21))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 1)) (not (>= (+ n1 (* n1 n7 n7 n21 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (not (>= n27 12)) (not (not (>= n27 12)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n7 n9) (>= (+ n18 (* (- 1) (* n3 n12))) 0) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (= (* n1 n21) (* n3 n21)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (>= n1 2) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= n27 12)))) +(check-sat) +(pop 1) +(set-info :notes "intvar_15 is is an integer variable created by the dio solver") +(declare-fun intvar_15 () Int) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (not (>= (* n3 n21) 12)) (not (not (>= (* n3 n21) 12)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n7 n9) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (+ n18 (* (- 1) n33)) 1)) (= (* n1 n21) (* n3 n21)) (not (>= (+ (* 2 n9) (* (- 1) (* n1 n9))) 1)) (not (>= (+ n15 (* (- 1) n27)) 1)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (>= n1 2) (not (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7) (* n7 n21)) (= (* n5 n7) (* n5 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 1) (not (>= (+ (* 2 n12) (* (- 1) (* n3 n12))) 1)) (not (>= (* n3 n21) 12)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n1 n7) (* n1 n9)) (= (* n1 n7) (* (- 1) (* n1 n9))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n1 n5) (* n1 n9)) (= (* n1 n5) (* (- 1) (* n1 n9))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n9) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n9) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n9) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n9) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n9) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n9) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n9) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n9) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n9) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n1 n9) (* n5 n5 n7)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n5 n5 n7)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n9) (* n3 n7)) (= (* n1 n9) (* (- 1) (* n3 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n9) (* n3 n5)) (= (* n1 n9) (* (- 1) (* n3 n5))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n9) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n9) (* n5 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n5 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n9) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n9) (* n7 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n7 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n9) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n9) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n9) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n9) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n9) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n9) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n9) 0) (not (>= (+ (* n1 n9) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n9) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n12) 0) (not (>= (+ (* n3 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n12) 0) (not (>= (+ (* n3 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 0)) (>= (+ (* n5 n7 n7) (* n5 n7 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n7 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n7 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n7 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21) 0) (ite (>= (* n7 n7 n7) 0) (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7))) 1) (>= (+ (* n5 n7 n21) (* n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n5 n7 n21) (* n7 n7 n7)) 0)) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n7 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n7 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n7 n21) (* n5 n9 n21)) (= (* n5 n7 n21) (* (- 1) (* n5 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n7 n21) (* n7 n9 n21)) (= (* n5 n7 n21) (* (- 1) (* n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n5 n7 n21) (* n5 n9 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n5 n9 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n7 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n5 n36) (* n1 n36 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n1 n36 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n5 n36) (* n1 n9 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n1 n9 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n5 n36) (* n3 n21 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n3 n21 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n36) (* n9 n36)) (= (* n5 n36) (* (- 1) (* n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0))) (ite (>= (* n21 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n21 n36))) 0)) (>= (+ (* n5 n36) (* n21 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n21 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n5 n36) (* n3 n7 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n3 n7 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n5 n36) (* n5 n9 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n5 n9 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n36) 0) (not (>= (+ (* n5 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n7 n21))) 0)) (>= (+ (* n5 n9) (* n7 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n7 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n7 n21))) 0)) (>= (+ (* n5 n5) (* n7 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n7 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n7 n21))) 0)) (>= (+ (* n5 n7) (* n7 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n7 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n7 n21))) 0)) (>= (+ (* n7 n7) (* n7 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n7 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n7 n21) (* n5 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n5 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n7 n21) (* n7 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n7 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0))) (ite (>= (* n21 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n21 n21))) 0)) (>= (+ (* n7 n21) (* n21 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n21 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n7 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n7 n21) 0) (not (>= (+ (* n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n7 n21) (* n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n21) (* n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n5 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n5 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n5 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n5 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n5 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n5 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n5 n7 n21) (* n5 n5 n9 n21)) (= (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n5 n5 n7 n21) (* n7 n7 n9 n21)) (= (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n7 n21) (* n5 n7 n9 n21)) (= (* n5 n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n5 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n5 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n5 n5 n36) (* n7 n9 n36)) (= (* n5 n5 n36) (* (- 1) (* n7 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n7 n21 n36))) 0)) (>= (+ (* n5 n5 n36) (* n7 n21 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n7 n21 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n9 n36))) 0)) (>= (+ (* n5 n5 n36) (* n5 n5 n9 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n5 n5 n9 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n36) (* n5 n9 n36)) (= (* n5 n5 n36) (* (- 1) (* n5 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n5 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21 n36) 0) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n21 n36))) 0)) (>= (+ (* n5 n5 n36) (* n5 n21 n36)) 1)) (ite (>= (* n5 n5 n36) 0) (not (>= (+ (* n5 n5 n36) (* n5 n21 n36)) 0)) (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)) (>= (+ (* n5 n9) (* n5 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n21))) 0)) (>= (+ (* n5 n5) (* n5 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n21))) 0)) (>= (+ (* n5 n7) (* n5 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21) 0) (ite (>= (* n7 n7) 0) (>= (+ (* n5 n21) (* (- 1) (* n7 n7))) 1) (>= (+ (* n5 n21) (* n7 n7)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n5 n21) (* n7 n7)) 0)) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n5 n21) (* n5 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n5 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n5 n21) (* n7 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n7 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0))) (ite (>= (* n21 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n21 n21))) 0)) (>= (+ (* n5 n21) (* n21 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n21 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n21) 0) (not (>= (+ (* n5 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7) (* n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5) (* n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7) (* n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n7 n7 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n7 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n7 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n7 n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n7 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n9 n21) (* n7 n7 n21)) (= (* n5 n9 n21) (* (- 1) (* n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n7 n7 n21) (* n7 n9 n21)) (= (* n7 n7 n21) (* (- 1) (* n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n7 n7 n21) 0) (>= (+ (* n5 n9 n36) (* (- 1) (* n7 n7 n21))) 1) (>= (+ (* n5 n9 n36) (* n7 n7 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n5 n9 n36) (* n7 n7 n21)) 0)) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n7 n7 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n7 n7 n21) 0) (not (>= (+ (* n7 n7 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n7 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n7 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n7 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n7 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n7 n36) (* n1 n36 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n1 n36 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n7 n36) (* n1 n9 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n1 n9 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n7 n36) (* n3 n21 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n3 n21 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n7 n36) (* n9 n36)) (= (* n7 n36) (* (- 1) (* n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0))) (ite (>= (* n21 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n21 n36))) 0)) (>= (+ (* n7 n36) (* n21 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n21 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n7 n36) (* n3 n7 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n3 n7 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n7 n36) (* n5 n9 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n5 n9 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n7 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n7 n36) 0) (not (>= (+ (* n7 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n7 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n5 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n5 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) (= (* n5 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n5 n7 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n7 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n5 n7 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* n5 n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n5 n5 n7 n21) (* n5 n5 n5 n9 n21)) (= (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) (= (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n7 n21) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n36) 0) (ite (>= (* n5 n5 n5 n36) 0) (not (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n7 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n5 n36) (* n7 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n5 n36) 0) (not (>= (+ (* n5 n5 n5 n36) (* n7 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n7 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n36) 0) (ite (>= (* n5 n5 n5 n36) 0) (not (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n5 n36) (* n5 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n5 n36) 0) (not (>= (+ (* n5 n5 n5 n36) (* n5 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n36) (* n7 n7 n7 n36)) (= (* n5 n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n5 n36) (* n5 n5 n9 n36)) (= (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n36) 0) (ite (>= (* n5 n5 n5 n36) 0) (not (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n21 n36))) 0)) (>= (+ (* n5 n5 n5 n36) (* n5 n5 n21 n36)) 1)) (ite (>= (* n5 n5 n5 n36) 0) (not (>= (+ (* n5 n5 n5 n36) (* n5 n5 n21 n36)) 0)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21) 0) (ite (>= (* n5 n7 n7) 0) (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n7))) 1) (>= (+ (* n5 n5 n21) (* n5 n7 n7)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n5 n21) (* n5 n7 n7)) 0)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21) 0) (ite (>= (* n7 n7 n7) 0) (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7))) 1) (>= (+ (* n5 n5 n21) (* n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n5 n5 n21) (* n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n5 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n5 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n5 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n21) (* n5 n9 n21)) (= (* n5 n5 n21) (* (- 1) (* n5 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n5 n5 n21) (* n7 n9 n21)) (= (* n5 n5 n21) (* (- 1) (* n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n5 n5 n21) (* n5 n9 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n5 n9 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n5 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0)) (>= (+ (* n1 n7) (* n3 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n21))) 0)) (>= (+ (* n1 n5) (* n3 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n21))) 0)) (>= (+ (* n3 n7) (* n3 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n21))) 0)) (>= (+ (* n3 n5) (* n3 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n21) (* n5 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n5 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n21) (* n7 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n7 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n21) 0) (not (>= (+ (* n3 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21) 0) (ite (>= (* n3 n5 n7) 0) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7))) 1) (>= (+ (* n1 n7 n21) (* n3 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n7)) 0)) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n5 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n5 n7) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n7))) 1) (>= (+ (* n1 n36 n36) (* n3 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n1 n36 n36) (* n3 n5 n7)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n3 n5 n7) (* n5 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n5 n7)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n21))) 0)) (>= (+ (* n3 n5 n7) (* n3 n7 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n7 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21) 0) (ite (>= (* n3 n5 n7) 0) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7))) 1) (>= (+ (* n1 n5 n21) (* n3 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n7)) 0)) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n5 n7) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n7))) 1) (>= (+ (* n1 n9 n36) (* n3 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n1 n9 n36) (* n3 n5 n7)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n21))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n5 n7) (* n3 n21 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n21 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n3 n5 n7) (* n3 n21 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n21 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n5 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n3 n5 n7) 0) (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n5 n7))) 1) (>= (+ (* n1 n21 n21) (* n3 n5 n7)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n1 n21 n21) (* n3 n5 n7)) 0)) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n5 n7) (* n3 n7 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n7 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n5 n7) (* n5 n9 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n9 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n7) 0) (not (>= (+ (* n3 n5 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n7 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n7 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n5 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n5) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n5 n5) (* n1 n36 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n36 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5) (* n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n21))) 0)) (>= (+ (* n1 n5 n5) (* n3 n7 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n7 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n5 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n5 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n5 n5) (* n1 n9 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n9 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n21))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n5 n5) (* n3 n21 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n21 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n1 n5 n5) (* n3 n21 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n21 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n21 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n21 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n21 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n5 n5) (* n3 n7 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n7 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n5 n5) (* n5 n9 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n9 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n36)) 0)) (>= (+ n1 n36) 1)) (ite (>= n1 0) (not (>= (+ n1 n36) 0)) (>= (+ n1 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5) 0) (not (>= (+ (* n1 n5 n5) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21) 0) (ite (>= (* n3 n7 n7) 0) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n7))) 1) (>= (+ (* n1 n7 n21) (* n3 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n1 n7 n21) (* n3 n7 n7)) 0)) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n7 n21) (* n1 n36 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n36 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n7 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n7 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n7 n21) (* n1 n9 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n9 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n7 n21) (* n3 n21 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n21 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n1 n7 n21) (* n3 n21 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n21 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n21))) 0)) (>= (+ (* n1 n7 n7) (* n1 n7 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n7 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n5 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n5 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n7 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n7 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n21 n21))) 0)) (>= (+ (* n1 n7 n21) (* n1 n21 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n21 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21) 0) (ite (>= (* n3 n5 n5) 0) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n5))) 1) (>= (+ (* n1 n7 n21) (* n3 n5 n5)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n5)) 0)) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n5))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n7 n21) (* n3 n7 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n7 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n7 n21) (* n5 n9 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n5 n9 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n21) 0) (not (>= (+ (* n1 n7 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n36) (* n1 n36 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n1 n36 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n36) (* n1 n9 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n1 n9 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n36) (* n3 n21 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n3 n21 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n9 0))) (ite (>= (* n9 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n9 n36))) 0)) (>= (+ (* n1 n36) (* n9 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n9 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n36) (* n3 n7 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n3 n7 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n36) (* n5 n9 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n5 n9 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n36) 0) (not (>= (+ (* n1 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n21))) 0)) (>= (+ (* n1 n7) (* n1 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n1 n7) (* n5 n5 n7)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n5 n5 n7)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n12)) 0)) (>= (+ n1 n12) 1)) (ite (>= n1 0) (not (>= (+ n1 n12) 0)) (>= (+ n1 (* (- 1) n12)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n7) (* n5 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n5 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n7) (* n7 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n7 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7) 0) (not (>= (+ (* n1 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n7 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n7 n7) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n7))) 1) (>= (+ (* n1 n36 n36) (* n3 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n1 n36 n36) (* n3 n7 n7)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n36)) 0)) (>= (+ n3 n36) 1)) (ite (>= n3 0) (not (>= (+ n3 n36) 0)) (>= (+ n3 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n3 n7 n7) (* n5 n5 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n5 n7)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n21))) 0)) (>= (+ (* n3 n7 n7) (* n3 n7 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n7 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21) 0) (ite (>= (* n3 n7 n7) 0) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n7 n7))) 1) (>= (+ (* n1 n5 n21) (* n3 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n1 n5 n21) (* n3 n7 n7)) 0)) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n7 n7) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n7))) 1) (>= (+ (* n1 n9 n36) (* n3 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n1 n9 n36) (* n3 n7 n7)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n21) 0) (ite (>= (* n3 n7 n7) 0) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n7 n7))) 1) (>= (+ (* n3 n5 n21) (* n3 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n5 n21) (* n3 n7 n7)) 0)) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n7 n7) (* n3 n21 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n21 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n3 n7 n7) (* n3 n21 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n21 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n5 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n7 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n7 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n3 n7 n7) 0) (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n7 n7))) 1) (>= (+ (* n1 n21 n21) (* n3 n7 n7)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n1 n21 n21) (* n3 n7 n7)) 0)) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n7 n7) (* n3 n7 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n7 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n7 n7) (* n5 n9 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n9 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n7) 0) (not (>= (+ (* n3 n7 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n7 n21) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n5 n7 n21))) 1) (>= (+ (* n1 n5 n5 n36) (* n1 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n36) (* n1 n5 n7 n21)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n7 n7))) 1) (>= (+ (* n1 n5 n7 n21) (* n1 n7 n7 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n7 n7 n7)) 0)) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n7 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n1 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n1 n5 n7 n21) (* n1 n7 n9 n21)) (= (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n7 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n21) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n21) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n21) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n21 n36))) 0)) (>= (+ (* n1 n5 n36) (* n1 n21 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n1 n21 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n5 n36) (* n1 n36 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n1 n36 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n1 n5 n36) (* n1 n9 n36)) (= (* n1 n5 n36) (* (- 1) (* n1 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n5 n36) (* n3 n21 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n3 n21 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n7 n9 n36))) 0)) (>= (+ (* n1 n5 n36) (* n7 n9 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n7 n9 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n7 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n36) (* n3 n7 n36)) (= (* n1 n5 n36) (* (- 1) (* n3 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n5 n36) (* n5 n9 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n5 n9 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n36) 0) (not (>= (+ (* n1 n5 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n21))) 0)) (>= (+ (* n1 n5) (* n1 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21) 0) (ite (>= (* n3 n7) 0) (>= (+ (* n1 n21) (* (- 1) (* n3 n7))) 1) (>= (+ (* n1 n21) (* n3 n7)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n1 n21) (* n3 n7)) 0)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21) 0) (ite (>= (* n3 n5) 0) (>= (+ (* n1 n21) (* (- 1) (* n3 n5))) 1) (>= (+ (* n1 n21) (* n3 n5)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n1 n21) (* n3 n5)) 0)) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n5))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n21) (* n5 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n5 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n21) (* n7 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n7 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n21) 0) (not (>= (+ (* n1 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n1 n5) (* n5 n5 n7)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n5 n5 n7)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n12)) 0)) (>= (+ n1 n12) 1)) (ite (>= n1 0) (not (>= (+ n1 n12) 0)) (>= (+ n1 (* (- 1) n12)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n5) (* n5 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n5 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n5) (* n7 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n7 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5) 0) (not (>= (+ (* n1 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n7 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n7 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n7) (* n5 n7 n7)) (= (* n5 n5 n7) (* (- 1) (* n5 n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n5 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n5 n7 n7) (* n5 n9 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n9 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n7 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n7 n7) 0) (not (>= (+ (* n5 n7 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n5 n5) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n5 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n5) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n5) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n5) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5) (* n5 n5 n7)) (= (* n5 n5 n5) (* (- 1) (* n5 n5 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n5 n5 n5) (* n5 n9 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n9 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n5 n5) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n21))) 1) (>= (+ (* n5 n5 n21 n21) (* n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n21 n21) (* n7 n7 n7 n21)) 0)) (not (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n7 n7 n7 n21))) 1) (>= (+ (* n5 n7 n21 n21) (* n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n21 n21) (* n7 n7 n7 n21)) 0)) (not (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n9 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n9 n21) (* (- 1) (* n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n7 n7 n7 n21) (* n7 n7 n9 n21)) (= (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7 n21) 0) (not (>= (+ (* n7 n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n7 n9 n21) (* n7 n7 n7 n21)) (= (* n5 n7 n9 n21) (* (- 1) (* n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n7 n7 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n7 n7 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n7 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n7 n7 n36) (* n7 n9 n36)) (= (* n7 n7 n36) (* (- 1) (* n7 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n21 n36))) 0)) (>= (+ (* n7 n7 n36) (* n7 n21 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n7 n21 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n5 n5 n9 n36))) 0)) (>= (+ (* n7 n7 n36) (* n5 n5 n9 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n5 n5 n9 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n5 n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n9 n36) (* n7 n7 n36)) (= (* n5 n9 n36) (* (- 1) (* n7 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n7 n7 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n7 n7 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n7 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21 n36) 0) (ite (>= (* n7 n7 n36) 0) (>= (+ (* n5 n21 n36) (* (- 1) (* n7 n7 n36))) 1) (>= (+ (* n5 n21 n36) (* n7 n7 n36)) 1)) (ite (>= (* n7 n7 n36) 0) (not (>= (+ (* n5 n21 n36) (* n7 n7 n36)) 0)) (not (>= (+ (* n5 n21 n36) (* (- 1) (* n7 n7 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n7 n7 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n7 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n7 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n7 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n7) (* n7 n7 n7)) (= (* n5 n5 n7) (* (- 1) (* n7 n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n7 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (>= (+ (* n5 n9 n21) (* (- 1) (* n7 n7 n7))) 1) (>= (+ (* n5 n9 n21) (* n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n5 n9 n21) (* n7 n7 n7)) 0)) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7) (* n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n7 n7 n7) 0) (>= (+ (* n5 n9 n36) (* (- 1) (* n7 n7 n7))) 1) (>= (+ (* n5 n9 n36) (* n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n5 n9 n36) (* n7 n7 n7)) 0)) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n7 n7 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n7 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n9) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5) (* n5 n9)) (= (* n5 n5) (* (- 1) (* n5 n9))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n9) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n9) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n9) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n9) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n9) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n7) (* n5 n9)) (= (* n5 n7) (* (- 1) (* n5 n9))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n9) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n9) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n9) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n5 n9) (* n5 n5 n7)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n5 n7)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n12)) 0)) (>= (+ n9 n12) 1)) (ite (>= n9 0) (not (>= (+ n9 n12) 0)) (>= (+ n9 (* (- 1) n12)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n9) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n9) (* n7 n7)) (= (* n5 n9) (* (- 1) (* n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n9) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n5 n9) (* n5 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n9) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n5 n9) (* n7 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n7 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (not (= n21 0))) (ite (>= (* n21 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n21 n21))) 0)) (>= (+ (* n5 n9) (* n21 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n21 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n9) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0))) (ite (>= (* n12 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n12 n21))) 0)) (>= (+ (* n5 n9) (* n12 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n12 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n9) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n9) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n9) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n9) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n9) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n9) 0) (not (>= (+ (* n5 n9) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n5 n7 n21) (* n3 n5 n7 n7 n21)) (= (* n1 n5 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n1 n5 n5 n7 n21) (* n1 n5 n7 n7 n21)) (= (* n1 n5 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n12) 0) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n3 n5 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* n3 n5 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* n3 n5 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n3 n5 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n1 n5 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n1 n5 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n5 n7 n21) (* n3 n5 n5 n5 n21)) (= (* n1 n5 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n1 n5 n5 n5 n21) (* n1 n5 n5 n7 n21)) (= (* n1 n5 n5 n5 n21) (* (- 1) (* n1 n5 n5 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n5 n5 n36) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n36) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n5 n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n7 n21 n36) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n7 n21 n36) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n5 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n5 n21 n21) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n21 n21) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n7 n9 n21) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n7 n9 n21) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n3 n5 n5 n7))) 1) (>= (+ (* n1 n7 n21 n21) (* n3 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n1 n7 n21 n21) (* n3 n5 n5 n7)) 0)) (not (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n3 n5 n5 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n21) 0) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n21))) 0)) (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7) 0) (not (>= (+ (* n3 n5 n5 n7) (* n3 n5 n7 n21)) 0)) (>= (+ (* n3 n5 n5 n7) (* (- 1) (* n3 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n5 n5 n36) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n36) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n5 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n7 n21 n36) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n7 n21 n36) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n5 n21 n21) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n21 n21) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n7 n9 n21) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n7 n9 n21) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n3 n5 n5 n36) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n5 n36) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n3 n5 n7 n7))) 1) (>= (+ (* n1 n7 n21 n21) (* n3 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n1 n7 n21 n21) (* n3 n5 n7 n7)) 0)) (not (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n3 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n21) 0) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n7) 0) (not (>= (+ (* n3 n5 n7 n7) (* n3 n5 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n7) (* (- 1) (* n3 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n7 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n7 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n7 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n21) (* n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n21) (* n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n21 n21) (* n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n21 n21) (* n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n7 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n7 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n9 n21) (* n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n9 n21) (* n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n7 n7 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n7 n7 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n7 n7 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n7 n7 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n21 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n21 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n7 n21 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n21 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n7 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n7 n7 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n7 n7 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n9 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n9 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n7 n7 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n7 n7) 0) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7))) 1) (>= (+ (* n5 n7 n9 n21) (* n7 n7 n7 n7)) 1)) (ite (>= (* n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n9 n21) (* n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n5 n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n5 n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n5 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n5 n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n7 n12) (* n1 n5 n5 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n1 n5 n5 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n7 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n7 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n7 n12) (* n1 n36 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n1 n36 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n7 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n7 n12) (* n1 n9 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n1 n9 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n7 n12) (* n3 n21 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n3 n21 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0))) (ite (>= (* n9 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n9 n36))) 0)) (>= (+ (* n7 n12) (* n9 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n9 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0))) (ite (>= (* n12 n21) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n12 n21))) 0)) (>= (+ (* n7 n12) (* n12 n21)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n12 n21)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n7 n12) (* n3 n7 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n3 n7 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n7 n12) (* n5 n9 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n5 n9 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n7 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n7 n12) 0) (not (>= (+ (* n7 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n7 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n21))) 1) (>= (+ (* n5 n5 n21 n21) (* n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n21 n21) (* n5 n7 n7 n21)) 0)) (not (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n9 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n9 n21) (* (- 1) (* n5 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n7 n7 n21) (* n7 n7 n9 n21)) (= (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n7 n7 n21) (* n5 n7 n9 n21)) (= (* n5 n7 n7 n21) (* (- 1) (* n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n7 n7 n21) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n7 n7 n21))) 1) (>= (+ (* n1 n5 n5 n36) (* n1 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n36) (* n1 n7 n7 n21)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n7 n7 n7) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n7 n7 n7))) 1) (>= (+ (* n1 n5 n5 n36) (* n1 n7 n7 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n36) (* n1 n7 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n5 n36) 0) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n5 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n5 n36) 0) (not (>= (+ (* n1 n5 n5 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n36) 0) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n36) 0) (not (>= (+ (* n1 n5 n5 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n7 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n12) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n9 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n12) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n12) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n12) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n5 n7 n12))) 1) (>= (+ (* n1 n5 n5 n36) (* n1 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n5 n36) (* n1 n5 n7 n12)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n5 n7 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n7 n7) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n5 n7 n7))) 1) (>= (+ (* n1 n5 n5 n36) (* n1 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n36) (* n1 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n1 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n7 n9 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n7 n9 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n9 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n36)) 0)) (>= (+ n3 n36) 1)) (ite (>= n3 0) (not (>= (+ n3 n36) 0)) (>= (+ n3 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n5) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n5 n9 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n5 n9 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n12) (* n1 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n1 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n1 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n36) (* n1 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n1 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n1 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n36) 0) (ite (>= (* n3 n5 n7 n21) 0) (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n3 n5 n7 n21))) 1) (>= (+ (* n1 n5 n5 n36) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5 n36) (* n3 n5 n7 n21)) 0)) (not (>= (+ (* n1 n5 n5 n36) (* (- 1) (* n3 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n7 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n7 n21))) 1) (>= (+ (* n1 n5 n21 n21) (* n1 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* n1 n7 n7 n21)) 0)) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n1 n7 n7 n21) (* n1 n7 n9 n21)) (= (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n7 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n21) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n21) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n5 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n5 n7 n7) (* n3 n5 n5 n5 n7)) (= (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n5 n5) (* n5 n5 n7)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n5 n7)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n5 n5) (* n5 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n5 n5) (* n7 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n7 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0))) (ite (>= (* n21 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n21 n21))) 0)) (>= (+ (* n5 n5) (* n21 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n21 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5) 0) (not (>= (+ (* n5 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n5 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n5 n5 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n5 n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n1 n3) (= n1 (* (- 1) n3))) (or (= (* n1 n5 n5 n7 n7) (* n3 n5 n5 n7 n7)) (= (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n7) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n5 n7 n7)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n5 n7 n7)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n7))) 1) (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n5 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n7 n7) (* n5 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n5 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n7))) 1) (>= (+ (* n5 n5 n5 n21) (* n5 n5 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n21) (* n5 n5 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n5 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5 n5) (* n5 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n5 n5 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n5 n5) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n5 n5 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n5 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5) 0) (not (>= (+ (* n5 n5 n5 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n36)) 0)) (>= (+ n1 n36) 1)) (ite (>= n1 0) (not (>= (+ n1 n36) 0)) (>= (+ n1 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n7 n7))) 1) (>= (+ (* n1 n5 n21 n21) (* n1 n7 n7 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n5 n21 n21) (* n1 n7 n7 n7)) 0)) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n7 n7))) 1) (>= (+ (* n1 n5 n5 n21) (* n1 n7 n7 n7)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n7 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n21) 0) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n21))) 0)) (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n21)) 1)) (ite (>= (* n1 n7 n7 n7) 0) (not (>= (+ (* n1 n7 n7 n7) (* n3 n5 n7 n21)) 0)) (>= (+ (* n1 n7 n7 n7) (* (- 1) (* n3 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n5 n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n1 n5 n5 n5 n5) (* n1 n5 n5 n7 n7)) (= (* n1 n5 n5 n5 n5) (* (- 1) (* n1 n5 n5 n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n5) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 0)) (>= (+ (* n3 n5 n5) (* n1 n5 n5 n5 n5)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n5 n5 n5 n5)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n5 n5))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) (= (* n5 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n5 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n5 n5 n21) (* n5 n5 n5 n9 n21)) (= (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n5 n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) (= (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n5 n21) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n5 n5 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n5 n5 n21) (* n5 n5 n9 n21)) (= (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n5 n5 n5 n21) (* n7 n7 n9 n21)) (= (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n21) 0) (not (>= (+ (* n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n5 n5 n5 n21) (* n5 n7 n9 n21)) (= (* n5 n5 n5 n21) (* (- 1) (* n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n5) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n21) 0) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5) 0) (not (>= (+ (* n1 n5 n5 n5) (* n3 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5) (* (- 1) (* n3 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n21 n36) 0) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n21 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n21 n36) 0) (not (>= (+ (* n1 n21 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n21 n36) 0) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n21 n36) (* n1 n36 n36)) 1)) (ite (>= (* n1 n21 n36) 0) (not (>= (+ (* n1 n21 n36) (* n1 n36 n36)) 0)) (>= (+ (* n1 n21 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n1 n3) (= n1 (* (- 1) n3))) (or (= (* n1 n21 n36) (* n3 n21 n36)) (= (* n1 n21 n36) (* (- 1) (* n3 n21 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n21 n36))) 0)) (>= (+ (* n1 n7 n36) (* n1 n21 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n1 n21 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n36) 0) (ite (>= (* n3 n5 n36) 0) (>= (+ (* n1 n21 n36) (* (- 1) (* n3 n5 n36))) 1) (>= (+ (* n1 n21 n36) (* n3 n5 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n1 n21 n36) (* n3 n5 n36)) 0)) (not (>= (+ (* n1 n21 n36) (* (- 1) (* n3 n5 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n21 n21) 0) (not (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n21 n21) 0) (not (>= (+ (* n5 n5 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n21 n21) 0) (not (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n21 n21) 0) (not (>= (+ (* n5 n5 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n21 n21) 0) (not (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n21 n21) 0) (not (>= (+ (* n5 n7 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n21 n21) 0) (not (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7 n21 n21) 0) (not (>= (+ (* n5 n7 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n7 n36) 0) (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n7 n36))) 1) (>= (+ (* n1 n7 n21 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n36) 0) (not (>= (+ (* n1 n7 n21 n36) (* n3 n5 n7 n36)) 0)) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n7 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n7 n36) 0) (not (>= (+ (* n3 n5 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n36) 0) (not (>= (+ (* n3 n5 n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n7 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n7 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n36)) 0)) (>= (+ n1 n36) 1)) (ite (>= n1 0) (not (>= (+ n1 n36) 0)) (>= (+ n1 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n9 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n7 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n7 n9 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n7 n9 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n9 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n7 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n7 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n5 n9 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n5 n9 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n1 n5 n12) (* n3 n5 n7 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n5 n7 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n36) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n36) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n21) (* n3 n5 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n3 n5 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n5 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n7 n7 n21) 0) (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1) (>= (+ (* n1 n7 n7 n21 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21 n21) (* n3 n5 n7 n7 n21)) 0)) (not (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n3 n5 n7 n7 n21) (* n3 n7 n7 n7 n21)) (= (* n3 n5 n7 n7 n21) (* (- 1) (* n3 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n3 n5 n5 n7 n21) (* n3 n5 n7 n7 n21)) (= (* n3 n5 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n9 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n9 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n3 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n3 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n7 n7 n36) 0) (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n7 n7 n36))) 1) (>= (+ (* n1 n7 n21 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n7 n36) 0) (not (>= (+ (* n1 n7 n21 n36) (* n3 n7 n7 n36)) 0)) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n7 n7 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n7 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n36)) 0)) (>= (+ n3 n36) 1)) (ite (>= n3 0) (not (>= (+ n3 n36) 0)) (>= (+ n3 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n7 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n7 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n9 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n5 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n21 n36) 0) (not (>= (+ (* n3 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n21 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n21 n36) 0) (not (>= (+ (* n3 n21 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n5 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n21 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n12 n21) 0) (not (>= (+ (* n3 n12 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n12 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n12 n21) 0) (not (>= (+ (* n3 n12 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n12 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n7 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n9 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n9 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n9 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n21 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n21 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n21 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n21 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n7 n21 n36) 0) (not (>= (+ (* n7 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n7 n21 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n7 n21 n36) 0) (not (>= (+ (* n7 n21 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n7 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n21 n36) 0) (not (>= (+ (* n21 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n21 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n21 n36) 0) (not (>= (+ (* n21 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n21 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n12 n21) 0) (not (>= (+ (* n1 n12 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n12 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n12 n21) 0) (not (>= (+ (* n1 n12 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n12 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n5 n5) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n7 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n9 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n9 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n5 n36) 0) (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n5 n36))) 1) (>= (+ (* n1 n7 n21 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n5 n36) 0) (not (>= (+ (* n1 n7 n21 n36) (* n3 n5 n5 n36)) 0)) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n5 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n7 n21 n21) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n5 n21 n36) 0) (not (>= (+ (* n5 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n5 n21 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n5 n21 n36) 0) (not (>= (+ (* n5 n21 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n5 n21 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n1 n5 n12) (* n1 n7 n21 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n1 n7 n21 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 0)) (>= (+ (* n3 n5 n36) (* n1 n7 n21 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n1 n7 n21 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n1 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n36) 0) (ite (>= (* n3 n5 n7 n21) 0) (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n7 n21))) 1) (>= (+ (* n1 n7 n21 n36) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n1 n7 n21 n36) (* n3 n5 n7 n21)) 0)) (not (>= (+ (* n1 n7 n21 n36) (* (- 1) (* n3 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n7 n7 n7 n21) 0) (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n7 n7 n7 n21))) 1) (>= (+ (* n1 n7 n7 n21 n21) (* n3 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21 n21) (* n3 n7 n7 n7 n21)) 0)) (not (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n5 n7 n21) 0) (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n5 n5 n7 n21))) 1) (>= (+ (* n1 n7 n7 n21 n21) (* n3 n5 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n1 n7 n7 n21 n21) (* n3 n5 n5 n7 n21)) 0)) (not (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n5 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n9 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n9 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n21 n21) 0) (not (>= (+ (* n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n21 n21) 0) (not (>= (+ (* n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n7 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n7 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n21 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n21 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n7 n7 n21 n21) 0) (not (>= (+ (* n7 n7 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n7 n7 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n7 n7 n21 n21) 0) (not (>= (+ (* n7 n7 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n7 n7 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5 n5) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n5 n5 n21) 0) (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1) (>= (+ (* n1 n7 n7 n21 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n7 n7 n21 n21) (* n3 n5 n5 n5 n21)) 0)) (not (>= (+ (* n1 n7 n7 n21 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n1 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n1 n7 n21 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n1 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n7 n21 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n1 n7 n7 n21 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n1 n7 n7 n21 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n1 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n7 n7 n36) 0) (not (>= (+ (* n3 n7 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n7 n36) 0) (not (>= (+ (* n3 n7 n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n9 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n36)) 0)) (>= (+ n1 n36) 1)) (ite (>= n1 0) (not (>= (+ n1 n36) 0)) (>= (+ n1 (* (- 1) n36)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n7 n9 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n7 n9 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n9 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n5) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n5 n9 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n5 n9 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n12) (* n3 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n36) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n36) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n21) (* n3 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n3 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n7 n7 n21) (* n3 n7 n7 n7 n21)) (= (* n1 n5 n7 n7 n21) (* (- 1) (* n3 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n12) 0) (ite (>= (* n3 n7 n7 n7 n21) 0) (>= (+ (* n3 n5 n5 n7 n12) (* (- 1) (* n3 n7 n7 n7 n21))) 1) (>= (+ (* n3 n5 n5 n7 n12) (* n3 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n12) (* n3 n7 n7 n7 n21)) 0)) (not (>= (+ (* n3 n5 n5 n7 n12) (* (- 1) (* n3 n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n3 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n3 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n3 n5 n5 n5 n21) (* n3 n7 n7 n7 n21)) (= (* n3 n5 n5 n5 n21) (* (- 1) (* n3 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n5 n5 n21) (* n3 n7 n7 n7 n21)) (= (* n1 n5 n5 n5 n21) (* (- 1) (* n3 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n7 n7 n21) 0) (not (>= (+ (* n3 n7 n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n7 n21) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n21))) 1) (>= (+ (* n1 n36 n36) (* n3 n7 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n1 n36 n36) (* n3 n7 n21)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n7 n12) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n12))) 1) (>= (+ (* n1 n36 n36) (* n3 n7 n12)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n1 n36 n36) (* n3 n7 n12)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n5 n21) (* n1 n36 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n36 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n5 n7) (* n1 n36 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n36 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n36)) 0)) (>= (+ n9 n36) 1)) (ite (>= n9 0) (not (>= (+ n9 n36) 0)) (>= (+ n9 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n9 n36) (* n1 n36 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n1 n36 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n5 n21) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n21))) 1) (>= (+ (* n1 n36 n36) (* n3 n5 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n1 n36 n36) (* n3 n5 n21)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n21 n36) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n21 n36))) 1) (>= (+ (* n1 n36 n36) (* n3 n21 n36)) 1)) (ite (>= (* n3 n21 n36) 0) (not (>= (+ (* n1 n36 n36) (* n3 n21 n36)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n21 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n5 n12) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n12))) 1) (>= (+ (* n1 n36 n36) (* n3 n5 n12)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n1 n36 n36) (* n3 n5 n12)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n21 n21) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n21 n21))) 1) (>= (+ (* n1 n36 n36) (* n3 n21 n21)) 1)) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n1 n36 n36) (* n3 n21 n21)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n21 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n12 n21) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n12 n21))) 1) (>= (+ (* n1 n36 n36) (* n3 n12 n21)) 1)) (ite (>= (* n3 n12 n21) 0) (not (>= (+ (* n1 n36 n36) (* n3 n12 n21)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n12 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n5 n12) (* n1 n36 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n1 n36 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n7 n12) (* n1 n36 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n1 n36 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n7 n7) (* n1 n36 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n36 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n36)) 0)) (>= (+ n9 n36) 1)) (ite (>= n9 0) (not (>= (+ n9 n36) 0)) (>= (+ n9 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n9 n36) (* n1 n36 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n1 n36 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n21 n21) (* n1 n36 n36)) 1)) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* n1 n36 n36)) 0)) (>= (+ (* n1 n21 n21) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n21 n36) 0) (not (>= (+ (* n21 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n21 n36) (* n1 n36 n36)) 1)) (ite (>= (* n21 n36) 0) (not (>= (+ (* n21 n36) (* n1 n36 n36)) 0)) (>= (+ (* n21 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n12 n21) 0) (not (>= (+ (* n1 n12 n21) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n12 n21) (* n1 n36 n36)) 1)) (ite (>= (* n1 n12 n21) 0) (not (>= (+ (* n1 n12 n21) (* n1 n36 n36)) 0)) (>= (+ (* n1 n12 n21) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n5 n5) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n5))) 1) (>= (+ (* n1 n36 n36) (* n3 n5 n5)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n1 n36 n36) (* n3 n5 n5)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n5))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n7 n36) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n36))) 1) (>= (+ (* n1 n36 n36) (* n3 n7 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n1 n36 n36) (* n3 n7 n36)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n7 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n7 n36) (* n1 n36 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n1 n36 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n36 n36))) 0)) (>= (+ (* n1 n5 n12) (* n1 n36 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n1 n36 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n36 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n1 0))) (ite (>= (* n1 n36 n36) 0) (ite (>= (* n3 n5 n36) 0) (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n36))) 1) (>= (+ (* n1 n36 n36) (* n3 n5 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n1 n36 n36) (* n3 n5 n36)) 0)) (not (>= (+ (* n1 n36 n36) (* (- 1) (* n3 n5 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n36) 0) (ite (>= (* n5 n7 n7 n36) 0) (not (>= (+ (* n5 n7 n7 n36) (* (- 1) (* n7 n7 n21 n36))) 0)) (>= (+ (* n5 n7 n7 n36) (* n7 n7 n21 n36)) 1)) (ite (>= (* n5 n7 n7 n36) 0) (not (>= (+ (* n5 n7 n7 n36) (* n7 n7 n21 n36)) 0)) (>= (+ (* n5 n7 n7 n36) (* (- 1) (* n7 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n21 n36) 0) (ite (>= (* n5 n5 n7 n36) 0) (not (>= (+ (* n5 n5 n7 n36) (* (- 1) (* n7 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n7 n36) (* n7 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n7 n36) 0) (not (>= (+ (* n5 n5 n7 n36) (* n7 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n7 n36) (* (- 1) (* n7 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7 n21) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n7 n21) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n21 n21) (* n7 n7 n7 n21 n21)) (= (* n5 n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n21 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n21) (* n7 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* n7 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n36) 0) (ite (>= (* n5 n7 n7 n36) 0) (not (>= (+ (* n5 n7 n7 n36) (* (- 1) (* n5 n7 n21 n36))) 0)) (>= (+ (* n5 n7 n7 n36) (* n5 n7 n21 n36)) 1)) (ite (>= (* n5 n7 n7 n36) 0) (not (>= (+ (* n5 n7 n7 n36) (* n5 n7 n21 n36)) 0)) (>= (+ (* n5 n7 n7 n36) (* (- 1) (* n5 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n21 n36) 0) (ite (>= (* n5 n5 n7 n36) 0) (not (>= (+ (* n5 n5 n7 n36) (* (- 1) (* n5 n7 n21 n36))) 0)) (>= (+ (* n5 n5 n7 n36) (* n5 n7 n21 n36)) 1)) (ite (>= (* n5 n5 n7 n36) 0) (not (>= (+ (* n5 n5 n7 n36) (* n5 n7 n21 n36)) 0)) (>= (+ (* n5 n5 n7 n36) (* (- 1) (* n5 n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n7 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7 n21) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n7 n7 n7 n21) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n21 n21) (* n5 n7 n7 n21 n21)) (= (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n21 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n21) (* n5 n7 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* n5 n7 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n7 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n7 n7 n36) (* n7 n7 n7 n36)) (= (* n5 n7 n7 n36) (* (- 1) (* n7 n7 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n9 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n36)) 0)) (>= (+ n1 n36) 1)) (ite (>= n1 0) (not (>= (+ n1 n36) 0)) (>= (+ n1 (* (- 1) n36)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n7 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n7) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n7 n9 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n7 n9 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n9 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n5) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n5 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n7 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n9 n36) (* n7 n7 n7 n36)) (= (* n5 n5 n9 n36) (* (- 1) (* n7 n7 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n5 n9 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n5 n9 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n5 n36) 0) (not (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n5 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n5 n36) 0) (not (>= (+ (* n3 n5 n5 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n1 n5 n12) (* n7 n7 n7 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n7 n7 n7 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n7 n36) (* n7 n7 n7 n36)) (= (* n5 n5 n7 n36) (* (- 1) (* n7 n7 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n36) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n36 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n36) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 0)) (>= (+ (* n3 n5 n7 n21) (* n7 n7 n7 n36)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n7 n7 n7 n36)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n7 n7 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n7 n7 n7 n21) (* n7 n7 n7 n7 n21)) (= (* n5 n7 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n5 n9 n21) (* n7 n7 n7 n7 n21)) (= (* n5 n5 n5 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n9 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n7 n9 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n7 n7 n21) 0) (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1) (>= (+ (* n5 n5 n5 n21 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n21 n21) (* n7 n7 n7 n7 n21)) 0)) (not (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n3 n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n7 n7 n21) (* n7 n7 n7 n7 n21)) (= (* n5 n5 n7 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n7 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n7 n7 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n7 n7 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n7 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n9 n36) (* n5 n7 n7 n36)) (= (* n5 n5 n9 n36) (* (- 1) (* n5 n7 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n36) 0) (ite (>= (* n5 n7 n7 n36) 0) (>= (+ (* n5 n5 n21 n36) (* (- 1) (* n5 n7 n7 n36))) 1) (>= (+ (* n5 n5 n21 n36) (* n5 n7 n7 n36)) 1)) (ite (>= (* n5 n7 n7 n36) 0) (not (>= (+ (* n5 n5 n21 n36) (* n5 n7 n7 n36)) 0)) (not (>= (+ (* n5 n5 n21 n36) (* (- 1) (* n5 n7 n7 n36))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n5 n7) (* n5 n5 n7)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n5 n7)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n5 n7) (* n5 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n5 n7) (* n7 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n7 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0))) (ite (>= (* n21 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n21 n21))) 0)) (>= (+ (* n5 n7) (* n21 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n21 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7) 0) (not (>= (+ (* n5 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n5 n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n5 n7 n7) (* n3 n5 n7 n7 n7)) (= (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n7 n7) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n7 n7 n7)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n7 n7 n7)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n7 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n5 n5 n7) 0) (not (>= (+ (* n5 n5 n5 n5 n7) (* n5 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n5 n5 n7) (* (- 1) (* n5 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n5 n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n5 n5 n7) 0) (not (>= (+ (* n5 n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n1 n5 n5 n5 n7) (* n1 n5 n5 n7 n7)) (= (* n1 n5 n5 n5 n7) (* (- 1) (* n1 n5 n5 n7 n7))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n7) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 0)) (>= (+ (* n3 n5 n5) (* n1 n5 n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n5 n5 n5 n7)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n7 n7 n21) (* n3 n5 n5 n7 n21)) (= (* n1 n5 n7 n7 n21) (* (- 1) (* n3 n5 n5 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n9 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n7 n9 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n5) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n7 n21) 0) (not (>= (+ (* n1 n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n5 n7 n7 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n1 n5 n7 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n1 n5 n7 n7 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n1 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n7 n7 n7 n7) (* n5 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n7 n7 n7 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n7 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n5 n7 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n7 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n5 n9 n21) (* n5 n7 n7 n7 n21)) (= (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n21) 0) (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n7 n21))) 1) (>= (+ (* n5 n5 n5 n21 n21) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n21 n21) (* n5 n7 n7 n7 n21)) 0)) (not (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n7 n9 n21) (* n5 n7 n7 n7 n21)) (= (* n5 n5 n7 n9 n21) (* (- 1) (* n5 n7 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n21) 0) (>= (+ (* n5 n5 n7 n21 n21) (* (- 1) (* n5 n7 n7 n7 n21))) 1) (>= (+ (* n5 n5 n7 n21 n21) (* n5 n7 n7 n7 n21)) 1)) (ite (>= (* n5 n7 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n21 n21) (* n5 n7 n7 n7 n21)) 0)) (not (>= (+ (* n5 n5 n7 n21 n21) (* (- 1) (* n5 n7 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n9 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n9 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n21 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n21 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n7 n9 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n7 n9 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n9 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n7 n9 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n7 n21 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n7 n21 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n21 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n7 n21 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n7 n21) 0) (ite (>= (* n5 n7 n7 n7 n7) 0) (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 1) (>= (+ (* n5 n5 n7 n7 n21) (* n5 n7 n7 n7 n7)) 1)) (ite (>= (* n5 n7 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* n5 n7 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n7 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n9 n21) (* n5 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n9 n21) (* n5 n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 1) (>= (+ (* n5 n5 n5 n21 n21) (* n5 n5 n7 n7 n7)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n5 n21 n21) (* n5 n5 n7 n7 n7)) 0)) (not (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n7 n21) 0) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n7 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* n5 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n7) 0) (not (>= (+ (* n5 n5 n7 n7 n7) (* n5 n5 n7 n7 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n7) (* (- 1) (* n5 n5 n7 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= (* n5 n7 n36) (* n7 n9 n36)) (= (* n5 n7 n36) (* (- 1) (* n7 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n7 0))) (ite (>= (* n7 n21 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n7 n21 n36))) 0)) (>= (+ (* n5 n7 n36) (* n7 n21 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n7 n21 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n7 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n5 n5 n9 n36))) 0)) (>= (+ (* n5 n7 n36) (* n5 n5 n9 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n5 n5 n9 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n5 n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n7 n36) (* n5 n9 n36)) (= (* n5 n7 n36) (* (- 1) (* n5 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n7 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n21 n36) 0) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* (- 1) (* n5 n21 n36))) 0)) (>= (+ (* n5 n7 n36) (* n5 n21 n36)) 1)) (ite (>= (* n5 n7 n36) 0) (not (>= (+ (* n5 n7 n36) (* n5 n21 n36)) 0)) (>= (+ (* n5 n7 n36) (* (- 1) (* n5 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n1 n5 n7) (* n5 n5 n7)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n5 n7)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n7 n7) (* n5 n5 n7)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n5 n5 n7)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n3 n7) (* n5 n5 n7)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n5 n5 n7)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n1 n7 n7) (* n5 n5 n7)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n5 n7)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n3 n5) (* n5 n5 n7)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n5 n5 n7)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n7))) 0)) (>= (+ (* n3 n5 n5) (* n5 n5 n7)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n5 n7)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n7))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n12) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n12) 0) (ite (>= (* n3 n5 n5 n7 n21) 0) (>= (+ (* n3 n5 n5 n7 n12) (* (- 1) (* n3 n5 n5 n7 n21))) 1) (>= (+ (* n3 n5 n5 n7 n12) (* n3 n5 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n12) (* n3 n5 n5 n7 n21)) 0)) (not (>= (+ (* n3 n5 n5 n7 n12) (* (- 1) (* n3 n5 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n7 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n7 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n12)) 0)) (>= (+ n1 n12) 1)) (ite (>= n1 0) (not (>= (+ n1 n12) 0)) (>= (+ n1 (* (- 1) n12)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n5 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n12) 0) (not (>= (+ (* n1 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n12) 0) (not (>= (+ (* n1 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n7 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n1 n3) (= n1 (* (- 1) n3))) (or (= (* n1 n5 n7 n12) (* n3 n5 n7 n12)) (= (* n1 n5 n7 n12) (* (- 1) (* n3 n5 n7 n12))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n12)) 0)) (>= (+ n7 n12) 1)) (ite (>= n7 0) (not (>= (+ n7 n12) 0)) (>= (+ n7 (* (- 1) n12)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (>= n12 2) (not (>= n12 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n12)) 0)) (>= (+ n5 n12) 1)) (ite (>= n5 0) (not (>= (+ n5 n12) 0)) (>= (+ n5 (* (- 1) n12)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n7 n12)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n7 n12)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n5 n7 n12))) 0)) (>= (+ (* n1 n5 n12) (* n3 n5 n7 n12)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n5 n7 n12)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n5 n7 n12))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n12 0) (ite (>= n21 0) (>= (+ n12 (* (- 1) n21)) 1) (>= (+ n12 n21) 1)) (ite (>= n21 0) (not (>= (+ n12 n21) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)))) (not (= n12 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n12) 0) (ite (>= (* n3 n5 n7 n21) 0) (>= (+ (* n3 n5 n7 n12) (* (- 1) (* n3 n5 n7 n21))) 1) (>= (+ (* n3 n5 n7 n12) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n12) (* n3 n5 n7 n21)) 0)) (not (>= (+ (* n3 n5 n7 n12) (* (- 1) (* n3 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n7 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n1 n5 n5 n7 n7))) 1) (>= (+ (* n1 n5 n5 n5 n21) (* n1 n5 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* n1 n5 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n1 n5 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* n5 n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* n5 n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n3 n5 n5 n5 n21) (* n3 n5 n5 n7 n21)) (= (* n3 n5 n5 n5 n21) (* (- 1) (* n3 n5 n5 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n5 n5 n5 n21) (* n3 n5 n5 n7 n21)) (= (* n1 n5 n5 n5 n21) (* (- 1) (* n3 n5 n5 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n7 n21))) 0)) (>= (+ (* n1 n5 n7) (* n3 n7 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n7 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n7 n21) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n21))) 1) (>= (+ (* n1 n9 n36) (* n3 n7 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n1 n9 n36) (* n3 n7 n21)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n7 n21) (* n3 n21 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n21 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n3 n7 n21) (* n3 n21 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n21 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n7 n21))) 0)) (>= (+ (* n1 n7 n7) (* n3 n7 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n7 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n5 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n5 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n7 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n7 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n3 n7 n21) 0) (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n7 n21))) 1) (>= (+ (* n1 n21 n21) (* n3 n7 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n1 n21 n21) (* n3 n7 n21)) 0)) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n7 n21))) 0)) (>= (+ (* n3 n5 n5) (* n3 n7 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n7 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n7 n21) (* n3 n7 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n7 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n7 n21) (* n5 n9 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n5 n9 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n21) 0) (not (>= (+ (* n3 n7 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n7 n12) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n12))) 1) (>= (+ (* n1 n9 n36) (* n3 n7 n12)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n1 n9 n36) (* n3 n7 n12)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n7 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n7 n12) (* n3 n21 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n21 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n12 n21) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n12 n21))) 0)) (>= (+ (* n3 n7 n12) (* n3 n12 n21)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n12 n21)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n1 n3) (= n1 (* (- 1) n3))) (or (= (* n1 n7 n12) (* n3 n7 n12)) (= (* n1 n7 n12) (* (- 1) (* n3 n7 n12))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n12 n21) 0) (ite (>= (* n3 n7 n12) 0) (>= (+ (* n1 n12 n21) (* (- 1) (* n3 n7 n12))) 1) (>= (+ (* n1 n12 n21) (* n3 n7 n12)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n1 n12 n21) (* n3 n7 n12)) 0)) (not (>= (+ (* n1 n12 n21) (* (- 1) (* n3 n7 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n7 n12) (* n3 n7 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n7 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n7 n12) (* n5 n9 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n5 n9 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n12) 0) (not (>= (+ (* n3 n7 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n5 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n5 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n5 n21) (* n1 n9 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n9 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n5 n21) (* n3 n21 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n21 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n1 n5 n21) (* n3 n21 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n21 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21) 0) (ite (>= (* n1 n7 n7) 0) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n7))) 1) (>= (+ (* n1 n5 n21) (* n1 n7 n7)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n5 n21) (* n1 n7 n7)) 0)) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n5 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n5 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n7 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n7 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n21 n21))) 0)) (>= (+ (* n1 n5 n21) (* n1 n21 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n21 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21) 0) (ite (>= (* n3 n5 n5) 0) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n5))) 1) (>= (+ (* n1 n5 n21) (* n3 n5 n5)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n5)) 0)) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n5))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n5 n21) (* n3 n7 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n7 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n5 n21) (* n5 n9 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n5 n9 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n21) 0) (not (>= (+ (* n1 n5 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n5 n7) (* n1 n9 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n9 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n21))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n5 n7) (* n3 n21 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n21 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n1 n5 n7) (* n3 n21 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n21 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n5 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n21 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n21 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n21 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n5 n7) (* n3 n7 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n7 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n5 n7) (* n5 n9 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n9 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n7) 0) (not (>= (+ (* n1 n5 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n5 n21) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n21))) 1) (>= (+ (* n1 n9 n36) (* n3 n5 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n1 n9 n36) (* n3 n5 n21)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n9 n36) (* n3 n21 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n3 n21 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n5 n12) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n12))) 1) (>= (+ (* n1 n9 n36) (* n3 n5 n12)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n1 n9 n36) (* n3 n5 n12)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n5 n12) (* n1 n9 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n1 n9 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n7 n12) (* n1 n9 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n1 n9 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n7 n7) (* n1 n9 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n9 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n9 n36) (* n1 n9 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n1 n9 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n3 n5 n5) 0) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n5))) 1) (>= (+ (* n1 n9 n36) (* n3 n5 n5)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n1 n9 n36) (* n3 n5 n5)) 0)) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n5))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n1 n7 n36) (* n1 n9 n36)) (= (* n1 n7 n36) (* (- 1) (* n1 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n9 n36) (* n5 n9 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n5 n9 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n9 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n9 n36) 0) (not (>= (+ (* n1 n9 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n9 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n9 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n9 n36))) 0)) (>= (+ (* n1 n5 n12) (* n1 n9 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n1 n9 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n9 n36) (* n3 n5 n36)) (= (* n1 n9 n36) (* (- 1) (* n3 n5 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n5 n21) (* n3 n21 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n21 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n3 n5 n21) (* n3 n21 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n21 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n21))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n5 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n5 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n7 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n7 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n3 n5 n21) 0) (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n5 n21))) 1) (>= (+ (* n1 n21 n21) (* n3 n5 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n1 n21 n21) (* n3 n5 n21)) 0)) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n5 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n21))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n5 n21) (* n3 n7 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n7 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n5 n21) (* n5 n9 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n5 n9 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n21) 0) (not (>= (+ (* n3 n5 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n5 n12) (* n3 n21 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n21 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n21 n21) (* n3 n21 n36)) 1)) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* n3 n21 n36)) 0)) (>= (+ (* n3 n21 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n12 n21) 0) (not (>= (+ (* n3 n12 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n12 n21) (* n3 n21 n36)) 1)) (ite (>= (* n3 n12 n21) 0) (not (>= (+ (* n3 n12 n21) (* n3 n21 n36)) 0)) (>= (+ (* n3 n12 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n5 n12) (* n3 n21 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n3 n21 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n7 n12) (* n3 n21 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n21 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n7 n7) (* n3 n21 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n21 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n9 n36) (* n3 n21 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n3 n21 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n21 n21) (* n3 n21 n36)) 1)) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* n3 n21 n36)) 0)) (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n21 n36) 0) (not (>= (+ (* n21 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n21 n36) (* n3 n21 n36)) 1)) (ite (>= (* n21 n36) 0) (not (>= (+ (* n21 n36) (* n3 n21 n36)) 0)) (>= (+ (* n21 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n12 n21) 0) (not (>= (+ (* n1 n12 n21) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n12 n21) (* n3 n21 n36)) 1)) (ite (>= (* n1 n12 n21) 0) (not (>= (+ (* n1 n12 n21) (* n3 n21 n36)) 0)) (>= (+ (* n1 n12 n21) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n5 n5) (* n3 n21 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n21 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n7 n36) (* n3 n21 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n3 n21 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n7 n36) (* n3 n21 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n3 n21 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n1 n5 n12) (* n3 n21 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n21 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n21 n36))) 0)) (>= (+ (* n3 n5 n36) (* n3 n21 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n3 n21 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n12 n21) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n12 n21))) 0)) (>= (+ (* n3 n5 n12) (* n3 n12 n21)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n12 n21)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n7 n12) (* n3 n5 n12)) (= (* n1 n7 n12) (* (- 1) (* n3 n5 n12))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n12 n21) 0) (ite (>= (* n3 n5 n12) 0) (>= (+ (* n1 n12 n21) (* (- 1) (* n3 n5 n12))) 1) (>= (+ (* n1 n12 n21) (* n3 n5 n12)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n1 n12 n21) (* n3 n5 n12)) 0)) (not (>= (+ (* n1 n12 n21) (* (- 1) (* n3 n5 n12))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n5 n12) (* n3 n7 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n7 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n5 n12) (* n5 n9 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n5 n9 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n12) 0) (not (>= (+ (* n3 n5 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n1 n7 n7) (* n3 n21 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n21 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n21 n21) 0) (not (>= (+ (* n3 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n1 n3) (= n1 (* (- 1) n3))) (or (= (* n1 n21 n21) (* n3 n21 n21)) (= (* n1 n21 n21) (* (- 1) (* n3 n21 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n21 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n21 n21))) 0)) (>= (+ (* n3 n5 n5) (* n3 n21 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n21 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n12 n21) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n12 n21))) 0)) (>= (+ (* n1 n7 n12) (* n3 n12 n21)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n12 n21)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n12 0)) (not (= n21 0)) (not (= n3 0))) (ite (>= (* n3 n12 n21) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n12 n21))) 0)) (>= (+ (* n1 n5 n12) (* n3 n12 n21)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n12 n21)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n36 0)) (not (= n9 0))) (ite (>= (* n9 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n9 n36))) 0)) (>= (+ (* n5 n12) (* n9 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n9 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0))) (ite (>= (* n12 n21) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n12 n21))) 0)) (>= (+ (* n5 n12) (* n12 n21)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n12 n21)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n5 n12) (* n3 n7 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n3 n7 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n5 n12) (* n5 n9 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n5 n9 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n12) 0) (not (>= (+ (* n5 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n12 n21) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n12 n21))) 0)) (>= (+ (* n1 n7 n12) (* n1 n12 n21)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n1 n12 n21)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n1 n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n7 n12) (* n3 n7 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n7 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n7 n12) (* n5 n9 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n5 n9 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n12) 0) (not (>= (+ (* n1 n7 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n1 n5 n12) (* n1 n7 n12)) (= (* n1 n5 n12) (* (- 1) (* n1 n7 n12))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n5 n5 n9 n36))) 0)) (>= (+ (* n1 n5 n7 n12) (* n5 n5 n9 n36)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* n5 n5 n9 n36)) 0)) (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n5 n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n7 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n7 n12) 0) (not (>= (+ (* n1 n5 n7 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n7 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n7 n7) (* n5 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n5 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n7 n7) (* n7 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n7 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0))) (ite (>= (* n21 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n21 n21))) 0)) (>= (+ (* n7 n7) (* n21 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n21 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7) 0) (not (>= (+ (* n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n7) (* n5 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n5 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n7) (* n7 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n7 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n7) 0) (not (>= (+ (* n3 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n5 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n21 n21))) 0)) (>= (+ (* n1 n7 n7) (* n1 n21 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n21 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n7 n7) (* n3 n7 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n7 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n7 n7) (* n5 n9 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n9 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n7) 0) (not (>= (+ (* n1 n7 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n7 n7))) 1) (>= (+ (* n1 n5 n5 n21) (* n1 n5 n7 n7)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n5 n7 n7)) 0)) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n7 n7))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n7 n9) (= n7 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n21) 0) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n7 n7) 0) (not (>= (+ (* n1 n5 n7 n7) (* n3 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n7 n7) (* (- 1) (* n3 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n5) (* n5 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n5 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n5) (* n7 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n7 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5) 0) (not (>= (+ (* n3 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n36)) 0)) (>= (+ n7 n36) 1)) (ite (>= n7 0) (not (>= (+ n7 n36) 0)) (>= (+ n7 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n5 n7 n21) 0) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n21))) 0)) (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n21)) 1)) (ite (>= (* n1 n5 n5 n7) 0) (not (>= (+ (* n1 n5 n5 n7) (* n3 n5 n7 n21)) 0)) (>= (+ (* n1 n5 n5 n7) (* (- 1) (* n3 n5 n7 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n5 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n5 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n9 n21) (* n5 n5 n7 n9 n21)) (= (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n7 n9) (= n7 (* (- 1) n9)))) (or (= (* n5 n5 n5 n9 n21) (* n5 n5 n7 n7 n21)) (= (* n5 n5 n5 n9 n21) (* (- 1) (* n5 n5 n7 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n5 n9 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n7 n9 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n5 n9 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n9 n21) 0) (not (>= (+ (* n5 n5 n9 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n5 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n5 n9 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n5 n5 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n5 n5 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n5 n9 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n9 0) (not (>= (+ n9 (* (- 1) n21)) 0)) (>= (+ n9 n21) 1)) (ite (>= n9 0) (not (>= (+ n9 n21) 0)) (>= (+ n9 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n5 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n9 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n9 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n5 n9 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n9 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n5 n9 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n5 n9 n21) 0) (not (>= (+ (* n5 n9 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n5 n9 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n7 n9 n36))) 0)) (>= (+ (* n1 n7 n36) (* n7 n9 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n7 n9 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n7 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n9 n36) (* n7 n9 n36)) (= (* n5 n9 n36) (* (- 1) (* n7 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n7 n9 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n7 n9 n36) 0) (not (>= (+ (* n7 n9 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n7 n9 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n7 n9 n36))) 0)) (>= (+ (* n3 n5 n36) (* n7 n9 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n7 n9 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n7 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n7 n9) (= n7 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n9 n36) (* n3 n7 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n3 n7 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n9 n36) (* n5 n9 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n5 n9 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n9 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n9 n36) 0) (not (>= (+ (* n9 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n9 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n7 n9 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n7 n9 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n7 n9 n21) 0) (not (>= (+ (* n7 n7 n9 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n7 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n7 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n7 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n7 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n9 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n7 n9 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n7 n9 n21) (* n1 n7 n9 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n1 n7 n9 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n7 n9 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n7 n9 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n7 n9 n21) 0) (not (>= (+ (* n7 n9 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n7 n9 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n21 n21) 0) (not (>= (+ (* n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n21 n21) 0) (not (>= (+ (* n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n21 n21) 0) (not (>= (+ (* n1 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n21 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n21 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n7 n7 n21 n21) 0) (not (>= (+ (* n7 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n7 n7 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n7 n7 n21 n21) 0) (not (>= (+ (* n7 n7 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n7 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n5) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n3 n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n21)) 0)) (>= (+ n1 n21) 1)) (ite (>= n1 0) (not (>= (+ n1 n21) 0)) (>= (+ n1 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n9 n21) 0) (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1) (>= (+ (* n5 n5 n5 n21 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n5 n7 n9 n21) 0) (not (>= (+ (* n5 n5 n5 n21 n21) (* n5 n5 n7 n9 n21)) 0)) (not (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n1 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n1 n7 n21 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n1 n7 n21 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n5 n5 n5 n21 n21) (* n5 n5 n7 n21 n21)) (= (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n21 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n21) 0) (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n7 n21))) 1) (>= (+ (* n5 n5 n5 n21 n21) (* n5 n5 n7 n7 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n21 n21) (* n5 n5 n7 n7 n21)) 0)) (not (>= (+ (* n5 n5 n5 n21 n21) (* (- 1) (* n5 n5 n7 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n5 n21 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n5 n5 n5 n21 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n5 n5 n5 n21 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n5 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n21 n21) 0) (ite (>= (* n3 n5 n5) 0) (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n5 n5))) 1) (>= (+ (* n1 n21 n21) (* n3 n5 n5)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n1 n21 n21) (* n3 n5 n5)) 0)) (not (>= (+ (* n1 n21 n21) (* (- 1) (* n3 n5 n5))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n5 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n5 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n21 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n3 n5 n7 n21))) 1) (>= (+ (* n1 n5 n21 n21) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n1 n5 n21 n21) (* n3 n5 n7 n21)) 0)) (not (>= (+ (* n1 n5 n21 n21) (* (- 1) (* n3 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (not (= n12 0)) (not (= n21 0)) (not (= n1 0))) (ite (>= (* n1 n12 n21) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n12 n21))) 0)) (>= (+ (* n1 n5 n12) (* n1 n12 n21)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n1 n12 n21)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n1 n12 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (>= n21 2) (not (>= n21 (- 1)))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n3 n5 n5) (* n3 n7 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n7 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n5) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n7 0)) (not (= n9 0)) (not (= n1 0))) (ite (>= (* n1 n7 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n1 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n1 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n1 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n36)) 0)) (>= (+ n5 n36) 1)) (ite (>= n5 0) (not (>= (+ n5 n36) 0)) (>= (+ n5 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n5 n5) (* n5 n9 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n9 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n21)) 0)) (>= (+ n3 n21) 1)) (ite (>= n3 0) (not (>= (+ n3 n21) 0)) (>= (+ n3 (* (- 1) n21)) 1))) (ite (>= n7 0) (>= n7 2) (not (>= n7 (- 1)))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (ite (>= n7 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n7)) 0)) (>= (+ n3 n7) 1)) (ite (>= n3 0) (not (>= (+ n3 n7) 0)) (>= (+ n3 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (>= n36 2) (not (>= n36 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n5) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n5) 0) (not (>= (+ (* n3 n5 n5) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n5) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9)))) (or (= (* n1 n5 n5 n21) (* n1 n7 n9 n21)) (= (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n7 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n7)) 0)) (>= (+ n1 n7) 1)) (ite (>= n1 0) (not (>= (+ n1 n7) 0)) (>= (+ n1 (* (- 1) n7)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n5 n21) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n21 n21))) 0)) (>= (+ (* n1 n5 n5 n21) (* n1 n7 n21 n21)) 1)) (ite (>= (* n1 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n21) (* n1 n7 n21 n21)) 0)) (>= (+ (* n1 n5 n5 n21) (* (- 1) (* n1 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n5 n5 n21) 0) (not (>= (+ (* n3 n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n3 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n3 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n3 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n1 n3) (= n1 (* (- 1) n3))) (or (= (* n1 n7 n36) (* n3 n7 n36)) (= (* n1 n7 n36) (* (- 1) (* n3 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n7 n36) (* n5 n9 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n5 n9 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n7 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n7 n36) 0) (not (>= (+ (* n3 n7 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n36 0)) (not (= n7 0)) (not (= n3 0))) (ite (>= (* n3 n7 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n7 n36))) 0)) (>= (+ (* n1 n5 n12) (* n3 n7 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n7 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n7 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= (* n3 n5 n36) (* n3 n7 n36)) (= (* n3 n5 n36) (* (- 1) (* n3 n7 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n5 n5 n5 n21) 0) (not (>= (+ (* n1 n5 n5 n5 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n5 n5 n5 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n1 0) (>= n1 2) (not (>= n1 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n1 0))) (ite (>= (* n1 n5 n5 n5 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n1 n5 n5 n5 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n1 n5 n5 n5 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n1 n5 n5 n5 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n7 n36) (* n5 n9 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n5 n9 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n7) (= n5 (* (- 1) n7))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n7 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n7 n36) 0) (not (>= (+ (* n1 n7 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n7 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n1 n7 n9 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n1 n7 n9 n21) 0) (not (>= (+ (* n1 n7 n9 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n1 n7 n9 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (or (= n1 n3) (= n1 (* (- 1) n3)))) (or (= (* n1 n7 n9 n21) (* n3 n5 n7 n21)) (= (* n1 n7 n9 n21) (* (- 1) (* n3 n5 n7 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n5 n7 n36) (* n5 n5 n9 n36)) (= (* n5 n5 n7 n36) (* (- 1) (* n5 n5 n9 n36))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (or (= n5 n9) (= n5 (* (- 1) n9))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n5 n9 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n5 n9 n36) 0) (not (>= (+ (* n5 n9 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n5 n9 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n9 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n9)) 0)) (>= (+ n1 n9) 1)) (ite (>= n1 0) (not (>= (+ n1 n9) 0)) (>= (+ n1 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n1 n5 n12) (* n5 n9 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n5 n9 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n36 0)) (not (= n5 0)) (not (= n9 0))) (ite (>= (* n5 n9 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n5 n9 n36))) 0)) (>= (+ (* n3 n5 n36) (* n5 n9 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n5 n9 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n5 n9 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n5 n7 n9 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n5 n7 n9 n21) 0) (not (>= (+ (* n5 n7 n9 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n5 n7 n9 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (or (= n7 n9) (= n7 (* (- 1) n9))) (or (= (* n5 n5 n7 n7 n21) (* n5 n5 n7 n9 n21)) (= (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n5)) 0)) (>= (+ n3 n5) 1)) (ite (>= n3 0) (not (>= (+ n3 n5) 0)) (>= (+ n3 (* (- 1) n5)) 1))) (ite (>= n9 0) (>= n9 2) (not (>= n9 (- 1)))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n5 n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n5 n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n9 0) (ite (>= n3 0) (not (>= (+ n3 (* (- 1) n9)) 0)) (>= (+ n3 n9) 1)) (ite (>= n3 0) (not (>= (+ n3 n9) 0)) (>= (+ n3 (* (- 1) n9)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0)) (not (= n9 0))) (ite (>= (* n5 n7 n9 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 0)) (>= (+ (* n3 n5 n7 n21) (* n5 n7 n9 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n7 n21) (* n5 n7 n9 n21)) 0)) (>= (+ (* n3 n5 n7 n21) (* (- 1) (* n5 n7 n9 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n12 0) (not (>= (+ n12 (* (- 1) n36)) 0)) (>= (+ n12 n36) 1)) (ite (>= n12 0) (not (>= (+ n12 n36) 0)) (>= (+ n12 (* (- 1) n36)) 1))) (ite (>= n5 0) (ite (>= n1 0) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= (+ n1 n5) 1)) (ite (>= n1 0) (not (>= (+ n1 n5) 0)) (>= (+ n1 (* (- 1) n5)) 1))) (ite (>= n3 0) (>= n3 2) (not (>= n3 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n1 n5 n12) (* n3 n5 n5 n36)) 1)) (ite (>= (* n1 n5 n12) 0) (not (>= (+ (* n1 n5 n12) (* n3 n5 n5 n36)) 0)) (>= (+ (* n1 n5 n12) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n5 0) (>= n5 2) (not (>= n5 (- 1)))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n5 n5 n36))) 0)) (>= (+ (* n3 n5 n36) (* n3 n5 n5 n36)) 1)) (ite (>= (* n3 n5 n36) 0) (not (>= (+ (* n3 n5 n36) (* n3 n5 n5 n36)) 0)) (>= (+ (* n3 n5 n36) (* (- 1) (* n3 n5 n5 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n36 0) (ite (>= n21 0) (not (>= (+ n21 (* (- 1) n36)) 0)) (>= (+ n21 n36) 1)) (ite (>= n21 0) (not (>= (+ n21 n36) 0)) (>= (+ n21 (* (- 1) n36)) 1))) (or (= n5 n7) (= n5 (* (- 1) n7))) (not (= n36 0)) (not (= n5 0)) (not (= n3 0))) (ite (>= (* n3 n5 n5 n36) 0) (ite (>= (* n3 n5 n7 n21) 0) (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n3 n5 n7 n21))) 1) (>= (+ (* n3 n5 n5 n36) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n3 n5 n5 n36) (* n3 n5 n7 n21)) 0)) (not (>= (+ (* n3 n5 n5 n36) (* (- 1) (* n3 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n5 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 n21) 1)) (ite (>= n5 0) (not (>= (+ n5 n21) 0)) (>= (+ n5 (* (- 1) n21)) 1))) (or (= n1 n3) (= n1 (* (- 1) n3))) (not (= n21 0)) (not (= n7 0)) (not (= n1 0))) (ite (>= (* n1 n7 n21 n21) 0) (ite (>= (* n3 n5 n7 n21) 0) (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n3 n5 n7 n21))) 1) (>= (+ (* n1 n7 n21 n21) (* n3 n5 n7 n21)) 1)) (ite (>= (* n3 n5 n7 n21) 0) (not (>= (+ (* n1 n7 n21 n21) (* n3 n5 n7 n21)) 0)) (not (>= (+ (* n1 n7 n21 n21) (* (- 1) (* n3 n5 n7 n21))) 0))))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n36 0)) (not (= n21 0)) (not (= n5 0))) (ite (>= (* n5 n5 n21 n36) 0) (ite (>= (* n5 n5 n7 n36) 0) (not (>= (+ (* n5 n5 n7 n36) (* (- 1) (* n5 n5 n21 n36))) 0)) (>= (+ (* n5 n5 n7 n36) (* n5 n5 n21 n36)) 1)) (ite (>= (* n5 n5 n7 n36) 0) (not (>= (+ (* n5 n5 n7 n36) (* n5 n5 n21 n36)) 0)) (>= (+ (* n5 n5 n7 n36) (* (- 1) (* n5 n5 n21 n36))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (=> (and (ite (>= n21 0) (ite (>= n7 0) (not (>= (+ n7 (* (- 1) n21)) 0)) (>= (+ n7 n21) 1)) (ite (>= n7 0) (not (>= (+ n7 n21) 0)) (>= (+ n7 (* (- 1) n21)) 1))) (not (= n21 0)) (not (= n5 0)) (not (= n7 0))) (ite (>= (* n5 n5 n7 n21 n21) 0) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n21 n21))) 0)) (>= (+ (* n5 n5 n7 n7 n21) (* n5 n5 n7 n21 n21)) 1)) (ite (>= (* n5 n5 n7 n7 n21) 0) (not (>= (+ (* n5 n5 n7 n7 n21) (* n5 n5 n7 n21 n21)) 0)) (>= (+ (* n5 n5 n7 n7 n21) (* (- 1) (* n5 n5 n7 n21 n21))) 1)))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n7) (* (- 1) (* n7 n21))) 0)) (= (* n5 n7) (* n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n7) (* n7 n21)) (>= (* n5 n7) (* n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n7 n7 n7) 1) (>= (* n7 n7 n7) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n7) (* (- 1) (* n3 n21))) 0) (not (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= n7 n9) (>= n7 n9)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n9 (* (- 1) n21)) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (>= n1 1) (not (>= (+ n1 (* (- 1) n5)) 1)) (= (* n5 n21) (* n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n21) (* n7 n21)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (>= (+ n24 (* (- 1) n36)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n21) (* n7 n21)) (>= (* n5 n21) (* n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n1 (* (- 1) n5)) 0)) (>= n1 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n21) (* (- 1) (* n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (= (* n5 n21) (* (- 1) (* n7 n21))) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= n7 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (= (* n1 n7 n21) (* n3 n7 n21)) (= (* n5 n21) (* (- 1) (* n7 n21))) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= (+ n7 (* (- 1) (* n1 n7 n21)) (* n3 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n21) (* (- 1) (* n7 n21))) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= (+ n7 (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (= (* n5 n21) (* (- 1) (* n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= (+ n5 (* (- 1) (* n5 n5 n5 n21)) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n21) (* (- 1) (* n7 n21))) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= (+ n7 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (not (>= (+ (* n5 n7) (* (- 1) (* n7 n21))) 0)) (not (>= (+ (* n5 n21) (* n7 n21)) 1)) (>= (* n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) 0) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (= (* n5 n21) (* (- 1) (* n7 n21))) (>= (+ n7 (* n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (not (>= (+ (* n5 n21) (* n7 n21)) 1)) (>= (* n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n21) (- 1)) (= (* n5 n21) (* (- 1) (* n7 n21))) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= n5 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n12 (* (- 1) n21)) 0) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (not (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (>= (+ n24 (* (- 1) n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (= (* n5 n21) (* n7 n21)) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (>= (+ n9 (* (- 1) n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n7 n7 n21) 1) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (* n5 n7 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= (* n7 n7 n21) 0) (>= (+ (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n7 n7 n21) 0) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= (* n5 n5 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n15 (* (- 1) n18)) 1)) (>= (+ n15 (* (- 1) n27)) 0) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ (* n3 n12) (* (- 1) (* n3 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n9 (* (- 1) n21)) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n21) (* n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n9 (* (- 1) n21)) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n21) (* n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n7 n21) (* n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n36) (* n7 n36)) (>= (+ n12 (* (- 1) n21)) 0) (= (* n5 n5 n21) (* n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= (* n5 n21) (* n7 n21)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n5 0) (not (>= (* n5 n9) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n21) (* n7 n21)) 1)) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n7) (* (- 1) (* n7 n21))) 1)) (>= (* n5 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n1 n9) 0)) (>= (+ n15 (* (- 1) n30)) 0) (= n15 (+ n30 (* n1 n9) (* (- 1) (* n1 n36)) (* n1 n7 n21))) (>= (+ (* n1 n36) (* (- 1) (* n1 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= (+ (* n5 n7 n21) (* n7 n7 n21)) 1)) (>= (* n7 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n5 1) (not (>= (* n5 n9) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (not (>= (+ n5 (* (- 1) (* n5 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (>= (+ (* n5 n9) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (>= (* n5 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n7 n21) 0) (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1) (not (>= (+ (* n5 n21) (* n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n21) 0) (>= (* n5 n21) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n21 0)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n12 (* (- 1) n21)) 1)) (= n21 0) (>= n12 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n7 n21) 0) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n7 n21) 0) (= (* n5 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= n21 1)) (>= n9 0) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n7 n7 n7 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= n21 0) (= (* n7 n7 n7 n21) 0) (= (* n5 n5 n7 n21) 0) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n7 n21) 0) (= (* n5 n21) 0) (= (* n7 n7 n21) 0) (not (>= (* n5 n7 n21) 1)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n21) 0) (= (* n7 n21) 0) (= (* n5 n5 n7 n21) 0) (= (* n7 n7 n7 n21) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ n24 (* (- 1) n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= (* n5 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) 0) (= (* n5 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) 0) (= (* n5 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n1 n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* n7 n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (* n7 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n1 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (* n5 n36) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* (- 1) (* n1 n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* (- 1) (* n1 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n1 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n1 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* n1 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= (* n5 n5 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n7 n7 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n5 n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* (- 1) (* n7 n7 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n7 n21) 0) (= (* n7 n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n5 n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n7 n21) 0) (= (* n7 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n5 n36) (* n5 n5 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n7 n21) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ n12 (* (- 1) n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 1)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n5 (* n5 n21)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= n21 2)) (>= (+ n24 (* (- 1) n36)) 0) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (= n5 n7)) (not (>= (+ n7 (* (- 1) (* n7 n21))) 1)) (>= (+ n21 (* (- 1) (* n5 n5 n5 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n5 (* n5 n21)) (>= (+ n24 (* (- 1) n36)) 0) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (= n5 n7)) (not (>= (+ n7 (* (- 1) (* n7 n21))) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n12) 0)) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (not (>= (+ n3 (* (- 1) (* n3 n21))) 1)) (not (>= (+ n15 (* (- 1) n18)) 1)) (>= n3 0) (>= (+ n15 (* (- 1) n27)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n15 (* (- 1) n18)) 1)) (not (>= (* n3 n12) 0)) (>= (+ n15 (* (- 1) n18) (* n3 n12)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n3 (* (- 1) (* n3 n21))) 1)) (not (>= (* n3 n12) 0)) (>= n3 0) (>= (+ (* n3 n12) (* (- 1) (* n3 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n3 1)) (>= n3 0) (not (= n3 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (>= n5 1) (not (>= (+ n7 (* (- 1) (* n1 n7))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (* n3 n7 n7) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (>= (+ n24 (* (- 1) n36)) 0) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n7 (* n7 n21)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (not (>= n9 2)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (>= (+ n24 (* (- 1) n36)) 0) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n7 (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n21) (* n7 n7 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ n24 (* (- 1) n39)) 1)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= n5 (* n5 n21)) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= n7 (* n7 n21)) (>= (+ n5 (* (- 1) n7)) 0) (= (* n5 n36) (* n7 n36)) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n21) (* n7 n7 n21)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n21) (* n7 n7 n21)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= n21 2)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n21 (* (- 1) (* n5 n5 n5 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n21) (* n7 n7 n21)) (not (>= n21 2)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ n21 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n7 n21) (* n7 n7 n21)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n7 n21) (* n7 n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 2)) (>= n12 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n5 1) (not (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n7 (* n7 n21)) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= n21 2)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n7 (* n7 n21)) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n21 (* (- 1) (* n5 n5 n5 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (not (>= n21 2)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n7 (* n7 n21)) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n21 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n7 (* n7 n21)) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ n7 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n12)) (* n7 n21)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n7 (* n7 n21)) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n7 n21) (* n7 n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) (* n7 n21))) 1)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (>= (+ n7 (* (- 1) n36)) 0) (not (= n7 n36)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= n5 n21) (>= n5 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n5 (* (- 1) n21)) 0) (not (= n5 n21)) (not (>= n1 2)) (>= n21 1) (>= (+ n1 (* (- 1) n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n7 n21) (* n7 n7 n21)) (>= (* n5 n7 n21) (* n7 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n7 n21) (* n7 n7 n21)) 1)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n21 2)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (not (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ (* n7 n36) (* n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 0)) (not (>= n21 2)) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n7 (* n7 n21)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 0)) (not (>= n21 2)) (not (>= (+ n24 (* (- 1) n39)) 1)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n5 (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n24 (* (- 1) n36)) 0) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 0)) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= n21 2)) (= (* n5 n7 n21) (* n7 n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (= n7 (* n7 n21)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (not (>= (+ n12 (* (- 1) n21)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (= n9 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n21) (* n7 n7 n21)) (>= (+ n36 (* (- 1) (* n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n5 (* n5 n21)) (>= (+ n5 (* (- 1) n7)) 0) (= n7 (* n7 n21)) (>= n21 1) (= n9 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n21) (* n7 n7 n21)) (not (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n1 (* (- 1) n5)) 1)) (>= n1 2) (not (>= (+ n7 (* (- 1) (* n1 n7))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (not (>= (* n3 n7 n7) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n7 n7) 0)) (>= n1 0) (not (>= (+ n1 (* (- 1) (* n3 n7 n7))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n7 n7) 0)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (>= (+ (* n1 n5 n5) (* n3 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n7 n7) 0)) (= n3 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (not (>= (+ n3 (* (- 1) (* n1 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n3 n7 n7) 0)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n7 n7))) 1)) (>= (* n1 n5 n5) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n3 0) (>= n3 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n5 1) (not (>= n1 1)) (>= (+ n1 (* (- 1) n5)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5 n7 n21) 0) (= (* n1 n21) 0) (>= (+ n15 (* (- 1) n18)) 0) (= n15 (+ n33 (* n1 n9) (* (- 1) (* n1 n21)) (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21)))) (not (>= (* n1 n9) 1)) (= (* n1 n5 n36) 0) (>= (+ n18 (* (- 1) n33)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n15 (* (- 1) n18)) 1)) (= (* n3 n12) 0) (>= (+ n15 (* (- 1) n18) (* n3 n12)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n15 (* (- 1) n18)) 1)) (= (* n3 n12) 0) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (>= (+ n15 (* (- 1) n27)) 0) (>= (* n3 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n5 n5 n21) 1) (>= (* n5 n5 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n7 n7 n7 n21) 1) (>= (* n7 n7 n7 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n5 n5) (* (- 1) (* n5 n5 n21))) 1) (= n1 0) (>= (+ n1 (* (- 1) n12)) 0) (= n7 (* n7 n21)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (= (* n5 n7 n21) (* n7 n7 n21)) (not (>= (+ (* 2 n36) (* (- 1) (* n5 n36))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n21 0) (>= (+ n5 (* (- 1) n21)) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n1 n5 n5) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5 n5) 0) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (>= n21 0) (>= (+ n5 (* (- 1) n21)) 0) (not (>= (+ n7 (* (- 1) (* n1 n7))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n7 (* (- 1) (* n7 n21))) 1)) (not (= n7 n36)) (>= (+ n7 (* (- 1) n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 0)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n1 0) (>= (+ n1 (* (- 1) n12)) 0) (= n7 (* n7 n21)) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 0)) (= (* n5 n7 n21) (* n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n1 0) (>= (+ n1 (* (- 1) n12)) 0) (= n7 (* n7 n21)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (not (>= (+ (* 2 (* n5 n5 n7 n21)) (* (- 1) (* n5 n5 n5 n7 n21))) 1)) (>= n21 1) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n36) (* n7 n36)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= n5 (* n5 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (= (* n1 n9) 0) (>= (+ n9 (* (- 1) (* n1 n9))) 1) (= (* n5 n7 n21) (* n7 n7 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n5 (* (- 1) n21)) 1) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n5 n5 n7 n21))) 0)) (not (>= (+ (* 2 n36) (* (- 1) (* n5 n36))) 1)) (= n7 (* n7 n21)) (not (>= n1 1)) (>= (+ n1 (* (- 1) n12)) 0) (= (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n7 (* (- 1) n36)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= n5 (* n5 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (= (* n1 n9) 0) (>= (+ n9 (* (- 1) (* n1 n9))) 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* 2 n36) (* (- 1) (* n5 n36))) 1)) (>= (+ n5 (* (- 1) n21)) 1) (not (>= n1 1)) (>= (+ n1 (* (- 1) n12)) 0) (= (* n5 n5 n5 n36) (* n5 n5 n5 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n21 1) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n7 n36) (>= (+ n1 (* (- 1) n12)) 0) (not (>= n1 1)) (>= (+ n5 (* (- 1) n21)) 0) (>= (+ n24 (* (- 1) n36)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n36) (* n5 n5 n5 n7 n21)) 1)) (>= (* n5 n5 n5 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n5 n5 n7 n21) 0) (not (>= (+ (* n5 n5 n5 n36) (* n5 n5 n5 n7 n21)) 1)) (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= n7 (* n7 n21)) (>= (+ n5 (* (- 1) n7)) 0) (not (>= n21 2)) (>= (* n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (not (>= n21 2)) (>= n5 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= (* n1 n5 n36) 0) (= (* n1 n5 n7 n21) 0) (not (>= n21 2)) (>= (+ n5 (* (- 1) (* n1 n5 n36)) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (not (>= n21 2)) (>= (+ n5 (* (- 1) (* n5 n5 n5 n21)) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n5 (* (- 1) n7)) 0) (not (>= n21 2)) (>= (+ n7 (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (not (>= n1 1)) (not (>= n21 2)) (>= (+ n1 n5) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (not (>= n1 1)) (>= (+ n5 (* (- 1) n7)) 0) (not (>= n21 2)) (>= (+ n1 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (>= (+ n5 (* (- 1) n7)) 0) (not (>= n21 2)) (>= n7 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n1 0) (not (>= (+ n5 (* (- 1) n21)) 0)) (not (>= n21 2)) (not (>= (+ n1 (* (- 1) n5)) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= (* n1 n21) 0) (= n5 (* n5 n21)) (not (>= n21 2)) (>= (+ (* n1 n21) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= (* n1 n36) 0) (= n5 (* n5 n21)) (not (>= n21 2)) (>= (+ (* n1 n36) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= (* n3 n12) 0) (= n5 (* n5 n21)) (not (>= n21 2)) (>= (+ (* n3 n12) (* n5 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n21)) 0)) (= n5 (* n5 n21)) (not (>= n21 2)) (>= (* n5 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 1)) (not (>= (+ n24 (* (- 1) n39)) 1)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (* n5 n7 n21) 1) (not (>= (+ n12 (* (- 1) n21)) 0)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n9 (* (- 1) n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21))) 1)) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (>= (* n5 n7 n21) 1) (>= n5 0) (not (>= (+ n5 (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (* n5 n9) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n9) 0)) (not (>= (+ n5 (* (- 1) (* n5 n21))) 0)) (>= n5 (- 1)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (not (>= (+ n12 (* (- 1) n21)) 0)) (>= (+ n9 (* (- 1) n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= (+ n7 (* (- 1) (* n7 n21))) 0)) (>= n5 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n7 (* (- 1) n36)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= n1 1)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0)) (>= (+ n36 (* (- 1) (* n7 n21))) 0) (>= (+ n24 (* (- 1) n36)) 0) (not (>= (+ n7 (* (- 1) (* n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= n5 0) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n1 (* (- 1) n12)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n1 (* (- 1) n3)) 1) (>= n3 0) (not (>= n3 1)) (>= n1 0) (not (>= n1 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5 n5) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (>= (+ (* n1 n5 n5) (* n3 n5 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5 n5) 0) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 1) (>= (* n3 n5 n7) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n5 n7 n21) 0) (not (>= (* n1 n5 n36) 1)) (>= (+ (* n1 n5 n36) (* (- 1) (* n1 n5 n7 n21))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* 2 (* n7 n21)) (* (- 1) (* n1 n7 n21))) 1)) (= (* n5 n21) (* n7 n21)) (not (>= (+ (* 2 n5) (* (- 1) (* n5 n21))) 1)) (>= n5 1) (not (>= (* n1 n7 n21) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (>= n5 2) (>= (+ n5 (* (- 1) n7)) 0) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0)) (>= (+ n24 (* (- 1) n36)) 0) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (not (>= (+ (* 2 n5) (* (- 1) (* n5 n21))) 1)) (>= (+ n7 (* (- 1) n12)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n1 n21) (* n3 n21)) (>= (* n1 n21) (* n3 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 0) (not (= (* n1 n21) (* n3 n21))) (= (* n1 n21) 0) (= (* n1 n21) (* (- 1) (* n3 n21))))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n1 n21) (* (- 1) (* n3 n21))) 0) (not (= (* n1 n21) (* n3 n21))) (not (>= (* n1 n21) 1)) (>= (* n3 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n7) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n5 n7))) 0)) (= (* n1 n7) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n5 n7) 1)) (>= n5 2) (not (>= (+ (* 2 n5) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n7) (* n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ n36 (* (- 1) (* n7 n21))) 0) (not (>= n1 2)) (>= n5 2) (not (>= (+ (* 2 n5) (* (- 1) (* n5 n21))) 1)) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= (+ (* n5 n9) (* n5 n21)) 1)) (not (>= (+ (* n5 n7 n21) (* (- 1) (* n7 n7 n21))) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n36) (* n7 n36)) (>= (+ n24 (* (- 1) n36)) 0) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (not (>= (+ (* n5 n5 n36) (* (- 1) (* n5 n5 n7 n21))) 0)) (= n12 (+ n39 (* (- 1) (* n7 n7 n36)) (* n7 n7 n7 n21))) (not (>= (+ n24 (* (- 1) n39)) 1)) (>= (+ n1 (* (- 1) n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n1 n7) 0)) (= (* n1 n7) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n3 n7 n7) 0) (>= (* n3 n7 n7) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n12 0) (>= n12 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n1 n21) (* n3 n21)) (= (* n3 n12) 0) (= n18 (+ n27 (* n3 n12) (* (- 1) (* n3 n21)))) (= (* n1 n21) 0) (not (>= (+ n15 (* (- 1) n18)) 1)) (>= (+ n15 (* (- 1) n27)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n15 (+ n30 (* n1 n9) (* (- 1) (* n1 n36)) (* n1 n7 n21))) (not (>= (* n1 n7 n21) 1)) (= (* n1 n9) 0) (= (* n1 n36) 0) (>= (+ n15 (* (- 1) n30)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n7 0) (>= n7 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n7 n7 n7) 1)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (>= (* n5 n5 n5) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (* n7 n7 n7) 0)) (not (>= (+ (* n5 n5 n5) (* (- 1) (* n7 n7 n7))) 1)) (>= (+ (* n5 n5 n5) (* n7 n7 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (not (or (<= (* n3 n12) 0) (>= (* n3 n12) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n5 n21) 0) (not (>= (+ (* n5 n5 n21) (* n5 n7 n21)) 1)) (>= (* n5 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 1) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ n7 (* (- 1) (* n1 n7))) 1)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= n5 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n5 (* n1 n5)) (>= (* n5 n7 n21) (- 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (* n1 n5) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ n5 (* (- 1) (* n1 n5))) 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ (* 7 n5) (* (- 1) (* n1 n5))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= n5 (* n1 n5)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n5 (* n1 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= n7 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= n1 2)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n1 n5) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n1 n5 n5) (* n1 n5 n7)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n5 (* (- 1) (* n1 n5 n5)) (* n1 n5 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n5 n5 n5 n21) (* n5 n5 n7 n21)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n5 (* (- 1) n7)) 1)) (>= (+ n5 (* (- 1) (* n5 n5 n5 n21)) (* n5 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (= n7 (* n1 n7)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (+ n5 (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (= n7 (* n1 n7)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n7 (* n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= n7 (* n1 n7)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* 7 n7) (* (- 1) (* n1 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ n7 (* (- 1) (* n1 n7))) 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ n7 (* n1 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (* n1 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ n7 (* (- 1) (* n5 n7 n7 n21)) (* n7 n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= n1 2)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ n1 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ n7 (* (- 1) (* n5 n7 n36)) (* n7 n7 n36)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (= n7 (* n1 n7)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (+ n7 (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) (* n1 n7))) 1)) (= n5 (* n1 n5)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* n1 n5) (* n1 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (* n1 n5 n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (>= (+ (* n1 n5 n5) (* (- 1) (* n3 n5 n7))) 0) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (* n3 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n1 n5 n5) (* n1 n5 n7)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (* n1 n5 n7) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (>= n1 1) (not (>= (+ n1 (* (- 1) n3)) 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ n3 (* (- 1) (* n1 n5 n5))) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (+ (* n1 n5 n5) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (= (* n1 n5 n5) 0)) (>= (* n1 n5 n5) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* n1 n7) (* n1 n5 n5)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ n7 (* (- 1) (* n1 n7))) 1)) (= n5 (* n1 n5)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (>= (+ (* n1 n5) (* n1 n7)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n1 n7) (* n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (+ (* n1 n7) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (= n5 (* n1 n5)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n7 (* n1 n7)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n1 n5) (* n7 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (= n5 (* n1 n5)) (= n7 (* n1 n7)) (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= (+ (* n1 n7) (* (- 1) (* n1 n5 n5))) 1)) (not (>= (+ (* n1 n5 n5) (* (- 1) (* n1 n5 n7 n21))) 0)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (+ (* n1 n5) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) (- 1)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (* n7 n7 n21) 2))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 0) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (= (* n5 n5 n21) (* (- 1) (* n7 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ (* n7 n7 n21) (* n1 n5 n7 n21)) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 1) (= (* n1 n5 n7 n21) (* n1 n7 n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (* n1 n7 n7 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n5 n7 n21) 1) (= (* n1 n5 n5 n21) (* n1 n5 n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n7 n7 n21) (* n1 n5 n7 n21)) (>= (* n1 n5 n5 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (>= (+ n24 (* (- 1) n36)) 0) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= (* n5 n5 n21) (* n7 n7 n21)) (>= (+ n12 (* (- 1) n21)) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n7 n7 n21) (* n1 n5 n7 n21)) 1)) (>= (* n7 n7 n21) 0) (>= (* n1 n5 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n7 n7 n21) (* n1 n5 n7 n21)) 1)) (= (* n1 n5 n7 n21) (* n1 n7 n7 n21)) (>= (* n7 n7 n21) 1) (>= (* n1 n7 n7 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n7 n7 n21) (* n1 n5 n7 n21)) 1)) (= (* n1 n5 n5 n21) (* n1 n5 n7 n21)) (>= (* n7 n7 n21) 1) (>= (* n1 n5 n5 n21) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (not (>= n21 2)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (>= (* n7 n7 n21) 1) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= n7 (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)) (= n5 (* n5 n21)) (not (>= (+ n5 (* (- 1) n7)) 1)) (= n7 (* n7 n21)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= n21 2)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (>= (* n7 n7 n21) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ n36 (* (- 1) (* n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= n21 2)) (>= (* n7 n7 n21) 1) (= n5 (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n21))) 1)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= n12 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= (* n7 n7 n21) 0) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (* n5 n7 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (* n7 n7 n21) 1) (>= (+ (* n5 n5 n21) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= (* n7 n7 n21) 0) (>= (* n5 n5 n21) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (= n12 (+ n36 (* (- 1) (* n7 n21)) (* n7 n36) (* (- 1) (* n7 n7 n21)))) (= n9 (+ n24 (* (- 1) (* n5 n5 n21)) (* n5 n5 n5 n36) (* (- 1) (* n5 n5 n5 n7 n21)))) (>= (+ n24 (* (- 1) n36)) 0) (= (* n5 n9) (+ (* n5 n21) (* n5 n5 n21) (* (- 1) (* n5 n5 n36)) (* (- 1) (* n5 n5 n5 n36)) (* n5 n5 n7 n21) (* n5 n5 n5 n7 n21))) (not (>= (+ (* n5 n9) (* (- 1) (* n5 n21))) 0)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (>= (* n7 n7 n21) 1) (= n5 (* n5 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (not (>= (+ n7 (* (- 1) (* n7 n21))) 1)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= (+ n12 (* (- 1) n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ n5 (* (- 1) n7)) 1)) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (not (>= n21 2)) (>= (* n7 n7 n21) 1) (= n5 (* n5 n21)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n5 n5 n21) (* n5 n7 n21)) (= (* n5 n36) (* n7 n36)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (= n7 (* n7 n21)) (not (>= (+ (* n5 n5 n21) (* n7 n7 n21)) 1)) (>= n9 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (* n7 n21) 0) (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1) (not (>= (+ (* n5 n21) (* n7 n21)) 1)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n5 n21) (* n5 n7 n21)) (>= (+ n9 (* (- 1) n21)) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n36) (* n7 n36)) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (= (* n5 n5 n21) (* n7 n7 n21)))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (not (>= (+ (* n5 n36) (* n7 n36)) 1)) (= (* n5 n5 n21) (* n7 n7 n21)) (= (* n5 n5 n21) (* n5 n7 n21)) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (>= (* n7 n7 n21) 0) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (+ (* n5 n36) (* (- 1) (* n5 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (>= (+ (* n5 n36) (* n7 n36)) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (>= (* n7 n7 n21) 0) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n5 n5 n7 n21) (* n5 n7 n7 n21)) (= (* n5 n7 n7 n21) (* n7 n7 n7 n21)) (= (* n5 n5 n36) (* n5 n7 n36)) (= (* n5 n7 n36) (* n7 n7 n36)) (>= (* n5 n36) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n7 (* n1 n7)) (>= (+ n7 (* (- 1) (* n1 n7))) 1))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (>= n1 1) (not (>= (+ n1 (* (- 1) (* n3 n7 n7))) 1)) (= (* n3 n7 n7) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (= (* n5 n36) (* n7 n36))) (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 0) (= n21 0) (= (* n5 n36) (* (- 1) (* n7 n36))) (= (* n5 n7 n21) 0) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (not (= (* n5 n36) (* n7 n36))) (>= (+ (* n5 n36) (* (- 1) (* n7 n36))) 0) (not (>= (+ (* n5 n36) (* n7 n36)) 1)) (= (* n7 n7 n21) 0) (>= (+ (* n7 n36) (* (- 1) (* n7 n7 n21))) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= (* n7 n7 n7 n21) 0) (= n21 0) (= (* n5 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n7 n21) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (>= (+ (* n5 n21) (* (- 1) (* n5 n5 n36)) (* n5 n5 n7 n21)) 0) (not (>= (* n5 n5 n7 n21) 1)) (>= (+ n21 (* (- 1) (* n5 n36)) (* n5 n7 n21)) 0))) +(check-sat) +(pop 1) +(set-info :notes "theory lemma: expect valid") +(push 1) +(assert (and (= n21 0) (= (* n7 n7 n7 n21) 0) (= n9 (+ n21 (* n5 n21) (* (- 1) (* n5 n36)) (* (- 1) (* n5 n5 n36)) (* n5 n7 n21) (* n5 n5 n7 n21))) (= (* n5 n7 n21) 0) (= (* n5 n36) (* n7 n36)) (= (* n7 n7 n21) 0) (= (* n5 n7 n36) (* n7 n7 n36)) (= (* n5 n5 n36) (* n5 n7 n36)) (>= (+ (* n7 n12) (* (- 1) (* n7 n21))) 1) (= (* n7 n12) (+ (* n7 n36) (* (- 1) (* n7 n7 n21)) (* n7 n7 n36) (* (- 1) (* n7 n7 n7 n21)))) (not (>= (+ (* n5 n21) (* (- 1) (* n7 n21))) 1)) (not (>= (* n5 n5 n7 n21) 1)) (>= n9 0))) +(check-sat) +(pop 1) +(check-sat) +unsat +(get-model) +(error "Cannot get the current model unless immediately preceded by SAT/INVALID or UNKNOWN response.") diff --git a/test/regress/regress0/nl/nl-help-unsat-quant.smt2 b/test/regress/regress0/nl/nl-help-unsat-quant.smt2 new file mode 100644 index 000000000..45a504de3 --- /dev/null +++ b/test/regress/regress0/nl/nl-help-unsat-quant.smt2 @@ -0,0 +1,419 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic UFNIA) +(set-info :status unsat) +(set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-sort S5 0) +(declare-sort S6 0) +(declare-sort S7 0) +(declare-sort S8 0) +(declare-sort S9 0) +(declare-sort S10 0) +(declare-sort S11 0) +(declare-sort S12 0) +(declare-sort S13 0) +(declare-sort S14 0) +(declare-sort S15 0) +(declare-sort S16 0) +(declare-sort S17 0) +(declare-sort S18 0) +(declare-sort S19 0) +(declare-sort S20 0) +(declare-sort S21 0) +(declare-sort S22 0) +(declare-sort S23 0) +(declare-sort S24 0) +(declare-sort S25 0) +(declare-sort S26 0) +(declare-sort S27 0) +(declare-sort S28 0) +(declare-sort S29 0) +(declare-sort S30 0) +(declare-sort S31 0) +(declare-sort S32 0) +(declare-sort S33 0) +(declare-sort S34 0) +(declare-sort S35 0) +(declare-sort S36 0) +(declare-sort S37 0) +(declare-sort S38 0) +(declare-sort S39 0) +(declare-sort S40 0) +(declare-sort S41 0) +(declare-sort S42 0) +(declare-sort S43 0) +(declare-sort S44 0) +(declare-sort S45 0) +(declare-sort S46 0) +(declare-sort S47 0) +(declare-sort S48 0) +(declare-sort S49 0) +(declare-sort S50 0) +(declare-sort S51 0) +(declare-sort S52 0) +(declare-sort S53 0) +(declare-sort S54 0) +(declare-sort S55 0) +(declare-sort S56 0) +(declare-sort S57 0) +(declare-sort S58 0) +(declare-sort S59 0) +(declare-sort S60 0) +(declare-sort S61 0) +(declare-sort S62 0) +(declare-sort S63 0) +(declare-sort S64 0) +(declare-sort S65 0) +(declare-sort S66 0) +(declare-sort S67 0) +(declare-sort S68 0) +(declare-sort S69 0) +(declare-sort S70 0) +(declare-sort S71 0) +(declare-sort S72 0) +(declare-sort S73 0) +(declare-sort S74 0) +(declare-sort S75 0) +(declare-sort S76 0) +(declare-sort S77 0) +(declare-sort S78 0) +(declare-sort S79 0) +(declare-sort S80 0) +(declare-sort S81 0) +(declare-sort S82 0) +(declare-sort S83 0) +(declare-sort S84 0) +(declare-sort S85 0) +(declare-sort S86 0) +(declare-sort S87 0) +(declare-sort S88 0) +(declare-sort S89 0) +(declare-sort S90 0) +(declare-sort S91 0) +(declare-sort S92 0) +(declare-sort S93 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 (Int) S1) +(declare-fun f4 () Int) +(declare-fun f5 () Int) +(declare-fun f6 (S2 S3) Int) +(declare-fun f7 () S2) +(declare-fun f8 (S4 Int) S3) +(declare-fun f9 (S5 Int) S4) +(declare-fun f10 () S5) +(declare-fun f11 (S6 S3) S1) +(declare-fun f12 (S7 S8) S1) +(declare-fun f13 (S10 S9) S8) +(declare-fun f14 (S11 S9) S10) +(declare-fun f15 () S11) +(declare-fun f16 (S12 S13) S1) +(declare-fun f17 (S15 S14) S13) +(declare-fun f18 (S16 S14) S15) +(declare-fun f19 () S16) +(declare-fun f20 (S17 S14) S1) +(declare-fun f21 (S18 S3) S14) +(declare-fun f22 (S19 Int) S18) +(declare-fun f23 () S19) +(declare-fun f24 (S20 S21) S1) +(declare-fun f25 (S23 S22) S21) +(declare-fun f26 (S24 S22) S23) +(declare-fun f27 () S24) +(declare-fun f28 (S25 S22) S1) +(declare-fun f29 (S26 Int) S22) +(declare-fun f30 (S27 S3) S26) +(declare-fun f31 () S27) +(declare-fun f32 (S28 S9) S1) +(declare-fun f33 (S29 S3) S9) +(declare-fun f34 (S30 S3) S29) +(declare-fun f35 () S30) +(declare-fun f36 (S31 Int) S1) +(declare-fun f37 (S32 Int) S31) +(declare-fun f38 (S6) S32) +(declare-fun f39 (S3 S6) S1) +(declare-fun f40 (S33 S9) S28) +(declare-fun f41 (S7) S33) +(declare-fun f42 (S8 S7) S1) +(declare-fun f43 (S34 S14) S17) +(declare-fun f44 (S12) S34) +(declare-fun f45 (S13 S12) S1) +(declare-fun f46 (S35 S22) S25) +(declare-fun f47 (S20) S35) +(declare-fun f48 (S21 S20) S1) +(declare-fun f49 (S36 Int) S6) +(declare-fun f50 (S17) S36) +(declare-fun f51 (S14 S17) S1) +(declare-fun f52 (S37 S3) S31) +(declare-fun f53 (S25) S37) +(declare-fun f54 (S22 S25) S1) +(declare-fun f55 (S38 S3) S6) +(declare-fun f56 (S28) S38) +(declare-fun f57 (S9 S28) S1) +(declare-fun f58 (S39 S36) S28) +(declare-fun f59 (S31) S39) +(declare-fun f60 (S40 S38) S20) +(declare-fun f61 (S6) S40) +(declare-fun f62 (S41 S9) S7) +(declare-fun f63 (S42 S43) S1) +(declare-fun f64 (S8 S8) S42) +(declare-fun f65 (S44 S41) S43) +(declare-fun f66 (S28) S44) +(declare-fun f67 (S45 S14) S12) +(declare-fun f68 (S46 S47) S1) +(declare-fun f69 (S13 S13) S46) +(declare-fun f70 (S48 S45) S47) +(declare-fun f71 (S17) S48) +(declare-fun f72 (S49 S22) S20) +(declare-fun f73 (S50 S51) S1) +(declare-fun f74 (S21 S21) S50) +(declare-fun f75 (S52 S49) S51) +(declare-fun f76 (S25) S52) +(declare-fun f77 (S53 S3) S28) +(declare-fun f78 (S54 S53) S7) +(declare-fun f79 (S6) S54) +(declare-fun f80 (S55 Int) S28) +(declare-fun f81 (S56 S55) S12) +(declare-fun f82 (S31) S56) +(declare-fun f83 (S6) S1) +(declare-fun f84 (S7) S1) +(declare-fun f85 (S12) S1) +(declare-fun f86 (S20) S1) +(declare-fun f87 (S28) S1) +(declare-fun f88 (S6) S1) +(declare-fun f89 (S7) S1) +(declare-fun f90 (S12) S1) +(declare-fun f91 (S20) S1) +(declare-fun f92 (S28) S1) +(declare-fun f93 (S6) S32) +(declare-fun f94 (S7) S33) +(declare-fun f95 (S12) S34) +(declare-fun f96 (S17) S36) +(declare-fun f97 (S20) S35) +(declare-fun f98 (S25) S37) +(declare-fun f99 (S28) S38) +(declare-fun f100 (S57 S58) S1) +(declare-fun f101 (S59 S59) S57) +(declare-fun f102 (S9 Int) S59) +(declare-fun f103 (S7 S6) S58) +(declare-fun f104 (S60 S61) S1) +(declare-fun f105 (S62 S62) S60) +(declare-fun f106 (S14 Int) S62) +(declare-fun f107 (S12 S6) S61) +(declare-fun f108 (S63 S64) S1) +(declare-fun f109 (S65 S65) S63) +(declare-fun f110 (S22 Int) S65) +(declare-fun f111 (S20 S6) S64) +(declare-fun f112 (S66 S6) S20) +(declare-fun f113 (S28) S66) +(declare-fun f114 (S67 S68) S1) +(declare-fun f115 (S69 S69) S67) +(declare-fun f116 (Int S9) S69) +(declare-fun f117 (S6 S7) S68) +(declare-fun f118 (S70 S71) S1) +(declare-fun f119 (S72 S72) S70) +(declare-fun f120 (Int S14) S72) +(declare-fun f121 (S6 S12) S71) +(declare-fun f122 (S73 S74) S1) +(declare-fun f123 (S75 S75) S73) +(declare-fun f124 (Int S22) S75) +(declare-fun f125 (S6 S20) S74) +(declare-fun f126 (S76 S28) S12) +(declare-fun f127 (S6) S76) +(declare-fun f128 (S77 S6) S28) +(declare-fun f129 (S6) S77) +(declare-fun f130 (S78 S7) S43) +(declare-fun f131 (S7) S78) +(declare-fun f132 (S79 S12) S47) +(declare-fun f133 (S12) S79) +(declare-fun f134 (S80 S20) S51) +(declare-fun f135 (S20) S80) +(declare-fun f136 (S81 S28) S7) +(declare-fun f137 (S28) S81) +(declare-fun f138 (S82) S6) +(declare-fun f139 (S83 S84) Int) +(declare-fun f140 () S83) +(declare-fun f141 (S82 Int) S84) +(declare-fun f142 (S85) S7) +(declare-fun f143 (S85 S9) S84) +(declare-fun f144 (S86) S12) +(declare-fun f145 (S86 S14) S84) +(declare-fun f146 (S87) S20) +(declare-fun f147 (S87 S22) S84) +(declare-fun f148 (S88) S28) +(declare-fun f149 (S88 S3) S84) +(declare-fun f150 (S89 S6) S6) +(declare-fun f151 (S82) S89) +(declare-fun f152 (S90 S7) S7) +(declare-fun f153 (S85) S90) +(declare-fun f154 (S91 S12) S12) +(declare-fun f155 (S86) S91) +(declare-fun f156 (S92 S20) S20) +(declare-fun f157 (S87) S92) +(declare-fun f158 (S93 S28) S28) +(declare-fun f159 (S88) S93) +(declare-fun f160 (S31 S6) S1) +(declare-fun f161 (Int S31) S1) +(declare-fun f162 (S17 S12) S1) +(declare-fun f163 (S25 S20) S1) +(declare-fun f164 (S7 S43) S1) +(declare-fun f165 (S12 S47) S1) +(declare-fun f166 (S20 S51) S1) +(declare-fun f167 (S28 S7) S1) +(declare-fun f168 (S6 S28) S1) +(declare-fun f169 () S82) +(assert (not (= f1 f2))) +(assert (not (= (f3 (* f4 f5)) f1))) +(assert (= (f3 f4) f1)) +(assert (= (f3 f5) f1)) +(assert (forall ((?v0 Int)) (= (= (f3 ?v0) f1) (exists ((?v1 Int) (?v2 Int)) (= (f6 f7 (f8 (f9 f10 ?v1) ?v2)) ?v0))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (* (f6 f7 (f8 (f9 f10 ?v0) ?v1)) (f6 f7 (f8 (f9 f10 ?v2) ?v3))) (f6 f7 (f8 (f9 f10 (+ (* ?v0 ?v2) (* ?v1 ?v3))) (- (* ?v0 ?v3) (* ?v1 ?v2))))))) +(assert (forall ((?v0 S6)) (= (forall ((?v1 S3)) (= (f11 ?v0 ?v1) f1)) (forall ((?v1 Int) (?v2 Int)) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S7)) (= (forall ((?v1 S8)) (= (f12 ?v0 ?v1) f1)) (forall ((?v1 S9) (?v2 S9)) (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S12)) (= (forall ((?v1 S13)) (= (f16 ?v0 ?v1) f1)) (forall ((?v1 S14) (?v2 S14)) (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S17)) (= (forall ((?v1 S14)) (= (f20 ?v0 ?v1) f1)) (forall ((?v1 Int) (?v2 S3)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S20)) (= (forall ((?v1 S21)) (= (f24 ?v0 ?v1) f1)) (forall ((?v1 S22) (?v2 S22)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S25)) (= (forall ((?v1 S22)) (= (f28 ?v0 ?v1) f1)) (forall ((?v1 S3) (?v2 Int)) (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S28)) (= (forall ((?v1 S9)) (= (f32 ?v0 ?v1) f1)) (forall ((?v1 S3) (?v2 S3)) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S9) (?v3 S9)) (= (= (f13 (f14 f15 ?v0) ?v1) (f13 (f14 f15 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S14) (?v3 S14)) (= (= (f17 (f18 f19 ?v0) ?v1) (f17 (f18 f19 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3)) (= (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S22) (?v3 S22)) (= (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int)) (= (= (f29 (f30 f31 ?v0) ?v1) (f29 (f30 f31 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (= (= (f33 (f34 f35 ?v0) ?v1) (f33 (f34 f35 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (=> (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S9) (?v3 S9)) (=> (= (f13 (f14 f15 ?v0) ?v1) (f13 (f14 f15 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S14) (?v3 S14)) (=> (= (f17 (f18 f19 ?v0) ?v1) (f17 (f18 f19 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3)) (=> (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S22) (?v3 S22)) (=> (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int)) (=> (= (f29 (f30 f31 ?v0) ?v1) (f29 (f30 f31 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (=> (= (f33 (f34 f35 ?v0) ?v1) (f33 (f34 f35 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (= (= (f36 (f37 (f38 ?v0) ?v1) ?v2) f1) (= (f39 (f8 (f9 f10 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (= (= (f32 (f40 (f41 ?v0) ?v1) ?v2) f1) (= (f42 (f13 (f14 f15 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (= (= (f20 (f43 (f44 ?v0) ?v1) ?v2) f1) (= (f45 (f17 (f18 f19 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (= (= (f28 (f46 (f47 ?v0) ?v1) ?v2) f1) (= (f48 (f25 (f26 f27 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (= (= (f11 (f49 (f50 ?v0) ?v1) ?v2) f1) (= (f51 (f21 (f22 f23 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (= (= (f36 (f52 (f53 ?v0) ?v1) ?v2) f1) (= (f54 (f29 (f30 f31 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (= (= (f11 (f55 (f56 ?v0) ?v1) ?v2) f1) (= (f57 (f33 (f34 f35 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S31) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S36)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f36 ?v0 ?v1) f1) (=> (= (f39 (f8 (f9 f10 ?v2) ?v3) (f49 ?v4 ?v1)) f1) (= (f57 (f33 (f34 f35 (f8 ?v_0 ?v2)) (f8 ?v_0 ?v3)) (f58 (f59 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6) (?v1 S3) (?v2 Int) (?v3 Int) (?v4 S38)) (let ((?v_0 (f30 f31 ?v1))) (=> (= (f11 ?v0 ?v1) f1) (=> (= (f39 (f8 (f9 f10 ?v2) ?v3) (f55 ?v4 ?v1)) f1) (= (f48 (f25 (f26 f27 (f29 ?v_0 ?v2)) (f29 ?v_0 ?v3)) (f60 (f61 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S28) (?v1 S9) (?v2 S9) (?v3 S9) (?v4 S41)) (let ((?v_0 (f14 f15 ?v1))) (=> (= (f32 ?v0 ?v1) f1) (=> (= (f42 (f13 (f14 f15 ?v2) ?v3) (f62 ?v4 ?v1)) f1) (= (f63 (f64 (f13 ?v_0 ?v2) (f13 ?v_0 ?v3)) (f65 (f66 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S17) (?v1 S14) (?v2 S14) (?v3 S14) (?v4 S45)) (let ((?v_0 (f18 f19 ?v1))) (=> (= (f20 ?v0 ?v1) f1) (=> (= (f45 (f17 (f18 f19 ?v2) ?v3) (f67 ?v4 ?v1)) f1) (= (f68 (f69 (f17 ?v_0 ?v2) (f17 ?v_0 ?v3)) (f70 (f71 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S25) (?v1 S22) (?v2 S22) (?v3 S22) (?v4 S49)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f28 ?v0 ?v1) f1) (=> (= (f48 (f25 (f26 f27 ?v2) ?v3) (f72 ?v4 ?v1)) f1) (= (f73 (f74 (f25 ?v_0 ?v2) (f25 ?v_0 ?v3)) (f75 (f76 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S53)) (let ((?v_0 (f34 f35 ?v1))) (=> (= (f11 ?v0 ?v1) f1) (=> (= (f57 (f33 (f34 f35 ?v2) ?v3) (f77 ?v4 ?v1)) f1) (= (f42 (f13 (f14 f15 (f33 ?v_0 ?v2)) (f33 ?v_0 ?v3)) (f78 (f79 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S31) (?v1 Int) (?v2 S3) (?v3 S3) (?v4 S55)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f36 ?v0 ?v1) f1) (=> (= (f57 (f33 (f34 f35 ?v2) ?v3) (f80 ?v4 ?v1)) f1) (= (f45 (f17 (f18 f19 (f21 ?v_0 ?v2)) (f21 ?v_0 ?v3)) (f81 (f82 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6)) (= (= (f83 ?v0) f1) (forall ((?v1 Int)) (= (f39 (f8 (f9 f10 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S7)) (= (= (f84 ?v0) f1) (forall ((?v1 S9)) (= (f42 (f13 (f14 f15 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S12)) (= (= (f85 ?v0) f1) (forall ((?v1 S14)) (= (f45 (f17 (f18 f19 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S20)) (= (= (f86 ?v0) f1) (forall ((?v1 S22)) (= (f48 (f25 (f26 f27 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S28)) (= (= (f87 ?v0) f1) (forall ((?v1 S3)) (= (f57 (f33 (f34 f35 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S6)) (= (= (f88 ?v0) f1) (forall ((?v1 Int)) (not (= (f39 (f8 (f9 f10 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S7)) (= (= (f89 ?v0) f1) (forall ((?v1 S9)) (not (= (f42 (f13 (f14 f15 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S12)) (= (= (f90 ?v0) f1) (forall ((?v1 S14)) (not (= (f45 (f17 (f18 f19 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S20)) (= (= (f91 ?v0) f1) (forall ((?v1 S22)) (not (= (f48 (f25 (f26 f27 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S28)) (= (= (f92 ?v0) f1) (forall ((?v1 S3)) (not (= (f57 (f33 (f34 f35 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S6)) (= (exists ((?v1 S3)) (= (f11 ?v0 ?v1) f1)) (exists ((?v1 Int) (?v2 Int)) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S7)) (= (exists ((?v1 S8)) (= (f12 ?v0 ?v1) f1)) (exists ((?v1 S9) (?v2 S9)) (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S12)) (= (exists ((?v1 S13)) (= (f16 ?v0 ?v1) f1)) (exists ((?v1 S14) (?v2 S14)) (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S17)) (= (exists ((?v1 S14)) (= (f20 ?v0 ?v1) f1)) (exists ((?v1 Int) (?v2 S3)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S20)) (= (exists ((?v1 S21)) (= (f24 ?v0 ?v1) f1)) (exists ((?v1 S22) (?v2 S22)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S25)) (= (exists ((?v1 S22)) (= (f28 ?v0 ?v1) f1)) (exists ((?v1 S3) (?v2 Int)) (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S28)) (= (exists ((?v1 S9)) (= (f32 ?v0 ?v1) f1)) (exists ((?v1 S3) (?v2 S3)) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S3) (?v3 Int) (?v4 Int)) (=> (= ?v0 (f13 (f14 f15 ?v1) (f33 (f34 f35 ?v2) (f8 (f9 f10 ?v3) ?v4)))) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 Int) (?v3 Int) (?v4 Int)) (=> (= ?v0 (f17 (f18 f19 ?v1) (f21 (f22 f23 ?v2) (f8 (f9 f10 ?v3) ?v4)))) false)) false))) +(assert (forall ((?v0 S7) (?v1 S8)) (=> (forall ((?v2 S9) (?v3 S3) (?v4 Int) (?v5 Int)) (= (f12 ?v0 (f13 (f14 f15 ?v2) (f33 (f34 f35 ?v3) (f8 (f9 f10 ?v4) ?v5)))) f1)) (= (f12 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S12) (?v1 S13)) (=> (forall ((?v2 S14) (?v3 Int) (?v4 Int) (?v5 Int)) (= (f16 ?v0 (f17 (f18 f19 ?v2) (f21 (f22 f23 ?v3) (f8 (f9 f10 ?v4) ?v5)))) f1)) (= (f16 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S9)) (=> (forall ((?v1 S3) (?v2 Int) (?v3 Int)) (=> (= ?v0 (f33 (f34 f35 ?v1) (f8 (f9 f10 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 Int) (?v3 S3)) (=> (= ?v0 (f17 (f18 f19 ?v1) (f21 (f22 f23 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S14)) (=> (forall ((?v1 Int) (?v2 Int) (?v3 Int)) (=> (= ?v0 (f21 (f22 f23 ?v1) (f8 (f9 f10 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S22) (?v2 S3) (?v3 Int)) (=> (= ?v0 (f25 (f26 f27 ?v1) (f29 (f30 f31 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S3) (?v3 S3)) (=> (= ?v0 (f13 (f14 f15 ?v1) (f33 (f34 f35 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S28) (?v1 S9)) (=> (forall ((?v2 S3) (?v3 Int) (?v4 Int)) (= (f32 ?v0 (f33 (f34 f35 ?v2) (f8 (f9 f10 ?v3) ?v4))) f1)) (= (f32 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S12) (?v1 S13)) (=> (forall ((?v2 S14) (?v3 Int) (?v4 S3)) (= (f16 ?v0 (f17 (f18 f19 ?v2) (f21 (f22 f23 ?v3) ?v4))) f1)) (= (f16 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S17) (?v1 S14)) (=> (forall ((?v2 Int) (?v3 Int) (?v4 Int)) (= (f20 ?v0 (f21 (f22 f23 ?v2) (f8 (f9 f10 ?v3) ?v4))) f1)) (= (f20 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S20) (?v1 S21)) (=> (forall ((?v2 S22) (?v3 S3) (?v4 Int)) (= (f24 ?v0 (f25 (f26 f27 ?v2) (f29 (f30 f31 ?v3) ?v4))) f1)) (= (f24 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S7) (?v1 S8)) (=> (forall ((?v2 S9) (?v3 S3) (?v4 S3)) (= (f12 ?v0 (f13 (f14 f15 ?v2) (f33 (f34 f35 ?v3) ?v4))) f1)) (= (f12 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S9)) (=> (= ?v0 (f13 (f14 f15 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 S14)) (=> (= ?v0 (f17 (f18 f19 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S14)) (=> (forall ((?v1 Int) (?v2 S3)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S22) (?v2 S22)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S22)) (=> (forall ((?v1 S3) (?v2 Int)) (=> (= ?v0 (f29 (f30 f31 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S9)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f33 (f34 f35 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S9) (?v2 S9)) (=> (= ?v0 (f13 (f14 f15 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S13)) (=> (forall ((?v1 S14) (?v2 S14)) (=> (= ?v0 (f17 (f18 f19 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S14)) (=> (forall ((?v1 Int) (?v2 S3)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S22) (?v2 S22)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S22)) (=> (forall ((?v1 S3) (?v2 Int)) (=> (= ?v0 (f29 (f30 f31 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S9)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f33 (f34 f35 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (=> (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (=> (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1) (= (f32 (f40 (f94 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (=> (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1) (= (f20 (f43 (f95 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) (= (f11 (f49 (f96 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) (= (f28 (f46 (f97 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (=> (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1) (= (f36 (f52 (f98 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (=> (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1) (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S9) (?v1 Int) (?v2 S9) (?v3 Int) (?v4 S7) (?v5 S6)) (= (= (f100 (f101 (f102 ?v0 ?v1) (f102 ?v2 ?v3)) (f103 ?v4 ?v5)) f1) (or (= (f42 (f13 (f14 f15 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S14) (?v1 Int) (?v2 S14) (?v3 Int) (?v4 S12) (?v5 S6)) (= (= (f104 (f105 (f106 ?v0 ?v1) (f106 ?v2 ?v3)) (f107 ?v4 ?v5)) f1) (or (= (f45 (f17 (f18 f19 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S22) (?v1 Int) (?v2 S22) (?v3 Int) (?v4 S20) (?v5 S6)) (= (= (f108 (f109 (f110 ?v0 ?v1) (f110 ?v2 ?v3)) (f111 ?v4 ?v5)) f1) (or (= (f48 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int) (?v4 S28) (?v5 S6)) (= (= (f48 (f25 (f26 f27 (f29 (f30 f31 ?v0) ?v1)) (f29 (f30 f31 ?v2) ?v3)) (f112 (f113 ?v4) ?v5)) f1) (or (= (f57 (f33 (f34 f35 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S9) (?v2 Int) (?v3 S9) (?v4 S6) (?v5 S7)) (= (= (f114 (f115 (f116 ?v0 ?v1) (f116 ?v2 ?v3)) (f117 ?v4 ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f42 (f13 (f14 f15 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S14) (?v2 Int) (?v3 S14) (?v4 S6) (?v5 S12)) (= (= (f118 (f119 (f120 ?v0 ?v1) (f120 ?v2 ?v3)) (f121 ?v4 ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f45 (f17 (f18 f19 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S22) (?v2 Int) (?v3 S22) (?v4 S6) (?v5 S20)) (= (= (f122 (f123 (f124 ?v0 ?v1) (f124 ?v2 ?v3)) (f125 ?v4 ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f48 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3) (?v4 S6) (?v5 S28)) (= (= (f45 (f17 (f18 f19 (f21 (f22 f23 ?v0) ?v1)) (f21 (f22 f23 ?v2) ?v3)) (f126 (f127 ?v4) ?v5)) f1) (or (= (f39 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f57 (f33 (f34 f35 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S6) (?v5 S6)) (let ((?v_0 (f9 f10 ?v0))) (= (= (f57 (f33 (f34 f35 (f8 ?v_0 ?v1)) (f8 (f9 f10 ?v2) ?v3)) (f128 (f129 ?v4) ?v5)) f1) (or (= (f39 (f8 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f39 (f8 (f9 f10 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S9) (?v3 S9) (?v4 S7) (?v5 S7)) (let ((?v_0 (f14 f15 ?v0))) (= (= (f63 (f64 (f13 ?v_0 ?v1) (f13 (f14 f15 ?v2) ?v3)) (f130 (f131 ?v4) ?v5)) f1) (or (= (f42 (f13 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f42 (f13 (f14 f15 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S14) (?v3 S14) (?v4 S12) (?v5 S12)) (let ((?v_0 (f18 f19 ?v0))) (= (= (f68 (f69 (f17 ?v_0 ?v1) (f17 (f18 f19 ?v2) ?v3)) (f132 (f133 ?v4) ?v5)) f1) (or (= (f45 (f17 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f45 (f17 (f18 f19 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S22) (?v3 S22) (?v4 S20) (?v5 S20)) (let ((?v_0 (f26 f27 ?v0))) (= (= (f73 (f74 (f25 ?v_0 ?v1) (f25 (f26 f27 ?v2) ?v3)) (f134 (f135 ?v4) ?v5)) f1) (or (= (f48 (f25 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f48 (f25 (f26 f27 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S28) (?v5 S28)) (let ((?v_0 (f34 f35 ?v0))) (= (= (f42 (f13 (f14 f15 (f33 ?v_0 ?v1)) (f33 (f34 f35 ?v2) ?v3)) (f136 (f137 ?v4) ?v5)) f1) (or (= (f57 (f33 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f57 (f33 (f34 f35 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (= (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (= (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (=> (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1) (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (=> (= (f32 (f40 (f94 ?v0) ?v1) ?v2) f1) (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (=> (= (f20 (f43 (f95 ?v0) ?v1) ?v2) f1) (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (=> (= (f11 (f49 (f96 ?v0) ?v1) ?v2) f1) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (=> (= (f28 (f46 (f97 ?v0) ?v1) ?v2) f1) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (=> (= (f36 (f52 (f98 ?v0) ?v1) ?v2) f1) (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (=> (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1) (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 Int) (?v2 Int)) (=> (= (f36 (f37 (f93 ?v0) ?v1) ?v2) f1) (=> (=> (= (f11 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S7) (?v1 S9) (?v2 S9)) (=> (= (f32 (f40 (f94 ?v0) ?v1) ?v2) f1) (=> (=> (= (f12 ?v0 (f13 (f14 f15 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S12) (?v1 S14) (?v2 S14)) (=> (= (f20 (f43 (f95 ?v0) ?v1) ?v2) f1) (=> (=> (= (f16 ?v0 (f17 (f18 f19 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S3)) (=> (= (f11 (f49 (f96 ?v0) ?v1) ?v2) f1) (=> (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S20) (?v1 S22) (?v2 S22)) (=> (= (f28 (f46 (f97 ?v0) ?v1) ?v2) f1) (=> (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 Int)) (=> (= (f36 (f52 (f98 ?v0) ?v1) ?v2) f1) (=> (=> (= (f28 ?v0 (f29 (f30 f31 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S28) (?v1 S3) (?v2 S3)) (=> (= (f11 (f55 (f99 ?v0) ?v1) ?v2) f1) (=> (=> (= (f32 ?v0 (f33 (f34 f35 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S82)) (= (= (f39 (f8 (f9 f10 ?v0) ?v1) (f138 ?v2)) f1) (< (f139 f140 (f141 ?v2 ?v0)) (f139 f140 (f141 ?v2 ?v1)))))) +(assert (forall ((?v0 S9) (?v1 S9) (?v2 S85)) (= (= (f42 (f13 (f14 f15 ?v0) ?v1) (f142 ?v2)) f1) (< (f139 f140 (f143 ?v2 ?v0)) (f139 f140 (f143 ?v2 ?v1)))))) +(assert (forall ((?v0 S14) (?v1 S14) (?v2 S86)) (= (= (f45 (f17 (f18 f19 ?v0) ?v1) (f144 ?v2)) f1) (< (f139 f140 (f145 ?v2 ?v0)) (f139 f140 (f145 ?v2 ?v1)))))) +(assert (forall ((?v0 S22) (?v1 S22) (?v2 S87)) (= (= (f48 (f25 (f26 f27 ?v0) ?v1) (f146 ?v2)) f1) (< (f139 f140 (f147 ?v2 ?v0)) (f139 f140 (f147 ?v2 ?v1)))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S88)) (= (= (f57 (f33 (f34 f35 ?v0) ?v1) (f148 ?v2)) f1) (< (f139 f140 (f149 ?v2 ?v0)) (f139 f140 (f149 ?v2 ?v1)))))) +(assert (forall ((?v0 S82) (?v1 Int) (?v2 Int) (?v3 S6)) (=> (< (f139 f140 (f141 ?v0 ?v1)) (f139 f140 (f141 ?v0 ?v2))) (= (f39 (f8 (f9 f10 ?v1) ?v2) (f150 (f151 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S85) (?v1 S9) (?v2 S9) (?v3 S7)) (=> (< (f139 f140 (f143 ?v0 ?v1)) (f139 f140 (f143 ?v0 ?v2))) (= (f42 (f13 (f14 f15 ?v1) ?v2) (f152 (f153 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S86) (?v1 S14) (?v2 S14) (?v3 S12)) (=> (< (f139 f140 (f145 ?v0 ?v1)) (f139 f140 (f145 ?v0 ?v2))) (= (f45 (f17 (f18 f19 ?v1) ?v2) (f154 (f155 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S87) (?v1 S22) (?v2 S22) (?v3 S20)) (=> (< (f139 f140 (f147 ?v0 ?v1)) (f139 f140 (f147 ?v0 ?v2))) (= (f48 (f25 (f26 f27 ?v1) ?v2) (f156 (f157 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S88) (?v1 S3) (?v2 S3) (?v3 S28)) (=> (< (f139 f140 (f149 ?v0 ?v1)) (f139 f140 (f149 ?v0 ?v2))) (= (f57 (f33 (f34 f35 ?v1) ?v2) (f158 (f159 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S82) (?v1 Int) (?v2 Int) (?v3 S6)) (let ((?v_0 (f8 (f9 f10 ?v1) ?v2))) (=> (<= (f139 f140 (f141 ?v0 ?v1)) (f139 f140 (f141 ?v0 ?v2))) (=> (= (f39 ?v_0 ?v3) f1) (= (f39 ?v_0 (f150 (f151 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S85) (?v1 S9) (?v2 S9) (?v3 S7)) (let ((?v_0 (f13 (f14 f15 ?v1) ?v2))) (=> (<= (f139 f140 (f143 ?v0 ?v1)) (f139 f140 (f143 ?v0 ?v2))) (=> (= (f42 ?v_0 ?v3) f1) (= (f42 ?v_0 (f152 (f153 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S86) (?v1 S14) (?v2 S14) (?v3 S12)) (let ((?v_0 (f17 (f18 f19 ?v1) ?v2))) (=> (<= (f139 f140 (f145 ?v0 ?v1)) (f139 f140 (f145 ?v0 ?v2))) (=> (= (f45 ?v_0 ?v3) f1) (= (f45 ?v_0 (f154 (f155 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S87) (?v1 S22) (?v2 S22) (?v3 S20)) (let ((?v_0 (f25 (f26 f27 ?v1) ?v2))) (=> (<= (f139 f140 (f147 ?v0 ?v1)) (f139 f140 (f147 ?v0 ?v2))) (=> (= (f48 ?v_0 ?v3) f1) (= (f48 ?v_0 (f156 (f157 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S88) (?v1 S3) (?v2 S3) (?v3 S28)) (let ((?v_0 (f33 (f34 f35 ?v1) ?v2))) (=> (<= (f139 f140 (f149 ?v0 ?v1)) (f139 f140 (f149 ?v0 ?v2))) (=> (= (f57 ?v_0 ?v3) f1) (= (f57 ?v_0 (f158 (f159 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S31) (?v1 S6)) (= (= (f160 ?v0 ?v1) f1) (forall ((?v2 Int)) (=> (= (f161 ?v2 ?v0) f1) (forall ((?v3 Int)) (=> (= (f161 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f39 (f8 (f9 f10 ?v2) ?v3) ?v1) f1) (= (f39 (f8 (f9 f10 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S17) (?v1 S12)) (= (= (f162 ?v0 ?v1) f1) (forall ((?v2 S14)) (=> (= (f51 ?v2 ?v0) f1) (forall ((?v3 S14)) (=> (= (f51 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f45 (f17 (f18 f19 ?v2) ?v3) ?v1) f1) (= (f45 (f17 (f18 f19 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S25) (?v1 S20)) (= (= (f163 ?v0 ?v1) f1) (forall ((?v2 S22)) (=> (= (f54 ?v2 ?v0) f1) (forall ((?v3 S22)) (=> (= (f54 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f48 (f25 (f26 f27 ?v2) ?v3) ?v1) f1) (= (f48 (f25 (f26 f27 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S7) (?v1 S43)) (= (= (f164 ?v0 ?v1) f1) (forall ((?v2 S8)) (=> (= (f42 ?v2 ?v0) f1) (forall ((?v3 S8)) (=> (= (f42 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f63 (f64 ?v2 ?v3) ?v1) f1) (= (f63 (f64 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S12) (?v1 S47)) (= (= (f165 ?v0 ?v1) f1) (forall ((?v2 S13)) (=> (= (f45 ?v2 ?v0) f1) (forall ((?v3 S13)) (=> (= (f45 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f68 (f69 ?v2 ?v3) ?v1) f1) (= (f68 (f69 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S20) (?v1 S51)) (= (= (f166 ?v0 ?v1) f1) (forall ((?v2 S21)) (=> (= (f48 ?v2 ?v0) f1) (forall ((?v3 S21)) (=> (= (f48 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f73 (f74 ?v2 ?v3) ?v1) f1) (= (f73 (f74 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S28) (?v1 S7)) (= (= (f167 ?v0 ?v1) f1) (forall ((?v2 S9)) (=> (= (f57 ?v2 ?v0) f1) (forall ((?v3 S9)) (=> (= (f57 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f42 (f13 (f14 f15 ?v2) ?v3) ?v1) f1) (= (f42 (f13 (f14 f15 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S6) (?v1 S28)) (= (= (f168 ?v0 ?v1) f1) (forall ((?v2 S3)) (=> (= (f39 ?v2 ?v0) f1) (forall ((?v3 S3)) (=> (= (f39 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f57 (f33 (f34 f35 ?v2) ?v3) ?v1) f1) (= (f57 (f33 (f34 f35 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S84)) (= (f141 f169 (f139 f140 ?v0)) ?v0))) +(assert (forall ((?v0 Int)) (=> (<= 0 ?v0) (= (f139 f140 (f141 f169 ?v0)) ?v0)))) +(assert (forall ((?v0 Int)) (=> (< ?v0 0) (= (f139 f140 (f141 f169 ?v0)) 0)))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/nl-unk-quant.smt2 b/test/regress/regress0/nl/nl-unk-quant.smt2 new file mode 100644 index 000000000..4ab034c7c --- /dev/null +++ b/test/regress/regress0/nl/nl-unk-quant.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic UFNIA) +(set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 () S2) +(declare-fun f4 (S3 Int) S2) +(declare-fun f5 () S3) +(declare-fun f6 (S4 S2) Int) +(declare-fun f7 () S4) +(declare-fun f8 () Int) +(declare-fun f9 (Int) S1) +(declare-fun f10 () Int) +(declare-fun f11 () S2) +(assert (not (= f1 f2))) +(assert (let ((?v_0 (f6 f7 f3)) (?v_1 (f6 f7 f11))) (not (=> (and (= f3 (f4 f5 (- (f6 f7 (f4 f5 f8)) 1))) (= (f9 (* (+ (* 4 f10) 1) (+ 1 ?v_0))) f1)) (=> (< f8 (+ 1 ?v_1)) (=> (< 0 f8) (< ?v_0 ?v_1))))))) +(assert (forall ((?v0 S2)) (= (f4 f5 (f6 f7 ?v0)) ?v0))) +(assert (forall ((?v0 Int)) (=> (<= 0 ?v0) (= (f6 f7 (f4 f5 ?v0)) ?v0)))) +(assert (forall ((?v0 Int)) (=> (< ?v0 0) (= (f6 f7 (f4 f5 ?v0)) 0)))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/nt-lemmas-bad.smt2 b/test/regress/regress0/nl/nt-lemmas-bad.smt2 new file mode 100644 index 000000000..c137214f6 --- /dev/null +++ b/test/regress/regress0/nl/nt-lemmas-bad.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-alg --nl-alg-tplanes +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status unsat) +(declare-fun skoX () Real) +(declare-fun skoY () Real) +(declare-fun pi () Real) +(assert (let ((?v_0 (* skoY skoY))) (and (<= (* skoY (+ (/ 11722184772546574330443595776 12341362258596589055135468582520347) (* pi (/ (- 20000116509245440) 3119868895908289175433)))) (* pi (- 20))) (and (<= 0 skoY) (and (not (<= (/ 31415927 10000000) pi)) (and (not (<= pi (/ 15707963 5000000))) (and (= ?v_0 (+ 277555600 (* skoX (* skoX (+ 15328072984 (* skoX (* skoX (+ 129098541721 (* skoX (* skoX (+ 21404723599 (* skoX (* skoX (+ 1024027285 (* skoX (* skoX 15132100)))))))))))))))) (= ?v_0 (+ 277555600 (* (/ 265 128) (* (/ 265 128) (+ 15328072984 (* (/ 265 128) (* (/ 265 128) (+ 129098541721 (* (/ 265 128) (* (/ 265 128) (+ 21404723599 (* (/ 265 128) (* (/ 265 128) (+ 1024027285 (* (/ 265 128) (* (/ 265 128) 15132100))))))))))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/ones.smt2 b/test/regress/regress0/nl/ones.smt2 new file mode 100644 index 000000000..88e73c56e --- /dev/null +++ b/test/regress/regress0/nl/ones.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) + +(assert (>= a 1)) +(assert (>= b 1)) +(assert (>= c 1)) +(assert (>= d 1)) +(assert (or (= a 1) (= b 1) (= c 1) (= d 1))) + +(assert (< (* a b c d) 1)) + +(check-sat) diff --git a/test/regress/regress0/nl/poly-1025.smt2 b/test/regress/regress0/nl/poly-1025.smt2 new file mode 100644 index 000000000..0a6e9dcf3 --- /dev/null +++ b/test/regress/regress0/nl/poly-1025.smt2 @@ -0,0 +1,29 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoX () Real) +(declare-fun skoY () Real) +(declare-fun skoZ () Real) +(assert (let ((?v_2 (not (<= skoZ 1)))) (let ((?v_3 (or (not (<= skoY 1)) ?v_2)) (?v_4 (not (<= skoX 1))) (?v_0 (* skoX (/ 1 4))) (?v_1 (* skoX (/ (- 5) 4))) (?v_5 (* skoX (/ 1 2))) (?v_6 (+ (/ (- 1) 4) (* skoX (/ (- 1) 4))))) (and (not (<= skoX 0)) (and (or (not (<= (* skoZ (* skoY (* skoY (+ (* skoX (* skoX (+ (/ (- 15) 4) ?v_0))) (* skoY (* skoX (* skoX (+ (/ 1 4) ?v_0)))))))) (* skoY (+ (* skoX (+ (/ 11 4) ?v_1)) (* skoY (* skoX (+ (/ (- 5) 4) ?v_1))))))) ?v_2) (and ?v_3 (and (or ?v_4 ?v_3) (and (<= skoZ 2) (and (<= skoY 2) (and (<= skoX 2) (and (<= 1 skoZ) (and (<= 1 skoY) (and (<= 1 skoX) (and (or ?v_4 ?v_2) (or (not (<= (* skoZ (* skoY (+ (* skoX (+ (/ (- 7) 2) ?v_5)) (* skoY (* skoX (+ (/ 1 2) ?v_5)))))) (+ ?v_6 (* skoY ?v_6)))) ?v_2))))))))))))))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/quant-nl.smt2 b/test/regress/regress0/nl/quant-nl.smt2 new file mode 100644 index 000000000..2544a5f2e --- /dev/null +++ b/test/regress/regress0/nl/quant-nl.smt2 @@ -0,0 +1,857 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic UFNIA) +(set-info :status unsat) +(set-info :source |Benchmarks from the paper: "Extending Sledgehammer with SMT Solvers" by Jasmin Blanchette, Sascha Bohme, and Lawrence C. Paulson, CADE 2011. Translated to SMT2 by Andrew Reynolds and Morgan Deters.|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(declare-sort S1 0) +(declare-sort S2 0) +(declare-sort S3 0) +(declare-sort S4 0) +(declare-sort S5 0) +(declare-sort S6 0) +(declare-sort S7 0) +(declare-sort S8 0) +(declare-sort S9 0) +(declare-sort S10 0) +(declare-sort S11 0) +(declare-sort S12 0) +(declare-sort S13 0) +(declare-sort S14 0) +(declare-sort S15 0) +(declare-sort S16 0) +(declare-sort S17 0) +(declare-sort S18 0) +(declare-sort S19 0) +(declare-sort S20 0) +(declare-sort S21 0) +(declare-sort S22 0) +(declare-sort S23 0) +(declare-sort S24 0) +(declare-sort S25 0) +(declare-sort S26 0) +(declare-sort S27 0) +(declare-sort S28 0) +(declare-sort S29 0) +(declare-sort S30 0) +(declare-sort S31 0) +(declare-sort S32 0) +(declare-sort S33 0) +(declare-sort S34 0) +(declare-sort S35 0) +(declare-sort S36 0) +(declare-sort S37 0) +(declare-sort S38 0) +(declare-sort S39 0) +(declare-sort S40 0) +(declare-sort S41 0) +(declare-sort S42 0) +(declare-sort S43 0) +(declare-sort S44 0) +(declare-sort S45 0) +(declare-sort S46 0) +(declare-sort S47 0) +(declare-sort S48 0) +(declare-sort S49 0) +(declare-sort S50 0) +(declare-sort S51 0) +(declare-sort S52 0) +(declare-sort S53 0) +(declare-sort S54 0) +(declare-sort S55 0) +(declare-sort S56 0) +(declare-sort S57 0) +(declare-sort S58 0) +(declare-sort S59 0) +(declare-sort S60 0) +(declare-sort S61 0) +(declare-sort S62 0) +(declare-sort S63 0) +(declare-sort S64 0) +(declare-sort S65 0) +(declare-sort S66 0) +(declare-sort S67 0) +(declare-sort S68 0) +(declare-sort S69 0) +(declare-sort S70 0) +(declare-sort S71 0) +(declare-sort S72 0) +(declare-sort S73 0) +(declare-sort S74 0) +(declare-sort S75 0) +(declare-sort S76 0) +(declare-sort S77 0) +(declare-sort S78 0) +(declare-sort S79 0) +(declare-sort S80 0) +(declare-sort S81 0) +(declare-sort S82 0) +(declare-sort S83 0) +(declare-sort S84 0) +(declare-sort S85 0) +(declare-sort S86 0) +(declare-sort S87 0) +(declare-sort S88 0) +(declare-sort S89 0) +(declare-sort S90 0) +(declare-sort S91 0) +(declare-sort S92 0) +(declare-sort S93 0) +(declare-sort S94 0) +(declare-sort S95 0) +(declare-sort S96 0) +(declare-sort S97 0) +(declare-sort S98 0) +(declare-sort S99 0) +(declare-sort S100 0) +(declare-sort S101 0) +(declare-sort S102 0) +(declare-sort S103 0) +(declare-sort S104 0) +(declare-sort S105 0) +(declare-sort S106 0) +(declare-sort S107 0) +(declare-sort S108 0) +(declare-sort S109 0) +(declare-sort S110 0) +(declare-sort S111 0) +(declare-sort S112 0) +(declare-sort S113 0) +(declare-sort S114 0) +(declare-sort S115 0) +(declare-sort S116 0) +(declare-sort S117 0) +(declare-sort S118 0) +(declare-sort S119 0) +(declare-sort S120 0) +(declare-sort S121 0) +(declare-sort S122 0) +(declare-sort S123 0) +(declare-sort S124 0) +(declare-sort S125 0) +(declare-sort S126 0) +(declare-sort S127 0) +(declare-sort S128 0) +(declare-sort S129 0) +(declare-sort S130 0) +(declare-sort S131 0) +(declare-sort S132 0) +(declare-sort S133 0) +(declare-sort S134 0) +(declare-sort S135 0) +(declare-sort S136 0) +(declare-sort S137 0) +(declare-sort S138 0) +(declare-sort S139 0) +(declare-sort S140 0) +(declare-sort S141 0) +(declare-sort S142 0) +(declare-sort S143 0) +(declare-sort S144 0) +(declare-sort S145 0) +(declare-sort S146 0) +(declare-sort S147 0) +(declare-sort S148 0) +(declare-sort S149 0) +(declare-sort S150 0) +(declare-sort S151 0) +(declare-sort S152 0) +(declare-sort S153 0) +(declare-sort S154 0) +(declare-sort S155 0) +(declare-sort S156 0) +(declare-sort S157 0) +(declare-sort S158 0) +(declare-sort S159 0) +(declare-sort S160 0) +(declare-sort S161 0) +(declare-sort S162 0) +(declare-sort S163 0) +(declare-sort S164 0) +(declare-sort S165 0) +(declare-sort S166 0) +(declare-sort S167 0) +(declare-sort S168 0) +(declare-sort S169 0) +(declare-sort S170 0) +(declare-sort S171 0) +(declare-sort S172 0) +(declare-sort S173 0) +(declare-sort S174 0) +(declare-sort S175 0) +(declare-sort S176 0) +(declare-sort S177 0) +(declare-sort S178 0) +(declare-sort S179 0) +(declare-sort S180 0) +(declare-sort S181 0) +(declare-sort S182 0) +(declare-sort S183 0) +(declare-sort S184 0) +(declare-sort S185 0) +(declare-fun f1 () S1) +(declare-fun f2 () S1) +(declare-fun f3 (Int) S1) +(declare-fun f4 () Int) +(declare-fun f5 () Int) +(declare-fun f6 (S2 S3) Int) +(declare-fun f7 () S2) +(declare-fun f8 (S4 Int) S3) +(declare-fun f9 (S5 Int) S4) +(declare-fun f10 () S5) +(declare-fun f11 (S6 S7) S1) +(declare-fun f12 (S9 S8) S7) +(declare-fun f13 (S10 S8) S9) +(declare-fun f14 () S10) +(declare-fun f15 (S11 S12) S1) +(declare-fun f16 (S13 S3) S12) +(declare-fun f17 (S14 S3) S13) +(declare-fun f18 () S14) +(declare-fun f19 (S15 S3) S1) +(declare-fun f20 (S16 S17) S1) +(declare-fun f21 (S19 S18) S17) +(declare-fun f22 (S20 S18) S19) +(declare-fun f23 () S20) +(declare-fun f24 (S21 S8) S1) +(declare-fun f25 (S22 S17) S8) +(declare-fun f26 (S23 S17) S22) +(declare-fun f27 () S23) +(declare-fun f28 (S24 S8) S21) +(declare-fun f29 (S6) S24) +(declare-fun f30 (S7 S6) S1) +(declare-fun f31 (S25 S3) S15) +(declare-fun f32 (S11) S25) +(declare-fun f33 (S12 S11) S1) +(declare-fun f34 (S26 Int) S1) +(declare-fun f35 (S27 Int) S26) +(declare-fun f36 (S15) S27) +(declare-fun f37 (S3 S15) S1) +(declare-fun f38 (S28 S18) S1) +(declare-fun f39 (S29 S18) S28) +(declare-fun f40 (S16) S29) +(declare-fun f41 (S17 S16) S1) +(declare-fun f42 (S30 S17) S16) +(declare-fun f43 (S21) S30) +(declare-fun f44 (S8 S21) S1) +(declare-fun f45 (S31 S8) S6) +(declare-fun f46 (S32 S33) S1) +(declare-fun f47 (S7 S7) S32) +(declare-fun f48 (S34 S31) S33) +(declare-fun f49 (S21) S34) +(declare-fun f50 (S35 S3) S11) +(declare-fun f51 (S36 S37) S1) +(declare-fun f52 (S12 S12) S36) +(declare-fun f53 (S38 S35) S37) +(declare-fun f54 (S15) S38) +(declare-fun f55 (S39 Int) S15) +(declare-fun f56 (S40 S39) S11) +(declare-fun f57 (S26) S40) +(declare-fun f58 (S41 S17) S21) +(declare-fun f59 (S42 S41) S6) +(declare-fun f60 (S16) S42) +(declare-fun f61 (S43 S18) S16) +(declare-fun f62 (S44 S43) S21) +(declare-fun f63 (S28) S44) +(declare-fun f64 (S6) S1) +(declare-fun f65 (S11) S1) +(declare-fun f66 (S15) S1) +(declare-fun f67 (S16) S1) +(declare-fun f68 (S21) S1) +(declare-fun f69 (S6) S1) +(declare-fun f70 (S11) S1) +(declare-fun f71 (S15) S1) +(declare-fun f72 (S16) S1) +(declare-fun f73 (S21) S1) +(declare-fun f74 (S6) S24) +(declare-fun f75 (S11) S25) +(declare-fun f76 (S15) S27) +(declare-fun f77 (S16) S29) +(declare-fun f78 (S21) S30) +(declare-fun f79 (S45 S6) S33) +(declare-fun f80 (S6) S45) +(declare-fun f81 (S46 S11) S37) +(declare-fun f82 (S11) S46) +(declare-fun f83 (S47 S15) S11) +(declare-fun f84 (S15) S47) +(declare-fun f85 (S48 S21) S6) +(declare-fun f86 (S21) S48) +(declare-fun f87 (S49 S50) S1) +(declare-fun f88 (S51 S51) S49) +(declare-fun f89 (Int S8) S51) +(declare-fun f90 (S15 S6) S50) +(declare-fun f91 (S52 S53) S1) +(declare-fun f92 (S54 S54) S52) +(declare-fun f93 (Int S3) S54) +(declare-fun f94 (S15 S11) S53) +(declare-fun f95 (S55 S56) S1) +(declare-fun f96 (S57 S57) S55) +(declare-fun f97 (S8 Int) S57) +(declare-fun f98 (S6 S15) S56) +(declare-fun f99 (S58 S59) S1) +(declare-fun f100 (S60 S60) S58) +(declare-fun f101 (S3 Int) S60) +(declare-fun f102 (S11 S15) S59) +(declare-fun f103 (S61 S16) S21) +(declare-fun f104 (S16) S61) +(declare-fun f105 (S62 S63) S1) +(declare-fun f106 (S64 S64) S62) +(declare-fun f107 (S18 Int) S64) +(declare-fun f108 (S16 S15) S63) +(declare-fun f109 (S65 S66) S1) +(declare-fun f110 (S67 S67) S65) +(declare-fun f111 (S18 S8) S67) +(declare-fun f112 (S16 S6) S66) +(declare-fun f113 (S68 S69) S1) +(declare-fun f114 (S70 S70) S68) +(declare-fun f115 (S18 S3) S70) +(declare-fun f116 (S16 S11) S69) +(declare-fun f117 (S71 S72) S1) +(declare-fun f118 (S73 S73) S71) +(declare-fun f119 (S17 Int) S73) +(declare-fun f120 (S21 S15) S72) +(declare-fun f121 (S74 S75) S1) +(declare-fun f122 (S76 S76) S74) +(declare-fun f123 (S17 S8) S76) +(declare-fun f124 (S21 S6) S75) +(declare-fun f125 (S77 S78) S1) +(declare-fun f126 (S79 S79) S77) +(declare-fun f127 (S17 S3) S79) +(declare-fun f128 (S21 S11) S78) +(declare-fun f129 (S80 S81) S1) +(declare-fun f130 (S82 S82) S80) +(declare-fun f131 (Int S18) S82) +(declare-fun f132 (S15 S16) S81) +(declare-fun f133 (S83 S84) S1) +(declare-fun f134 (S85 S85) S83) +(declare-fun f135 (S8 S18) S85) +(declare-fun f136 (S6 S16) S84) +(declare-fun f137 (S86 S87) S1) +(declare-fun f138 (S88 S88) S86) +(declare-fun f139 (S3 S18) S88) +(declare-fun f140 (S11 S16) S87) +(declare-fun f141 (S89 S90) S1) +(declare-fun f142 (S91 S91) S89) +(declare-fun f143 (Int S17) S91) +(declare-fun f144 (S15 S21) S90) +(declare-fun f145 (S92 S93) S1) +(declare-fun f146 (S94 S94) S92) +(declare-fun f147 (S8 S17) S94) +(declare-fun f148 (S6 S21) S93) +(declare-fun f149 (S95 S96) S1) +(declare-fun f150 (S97 S97) S95) +(declare-fun f151 (S3 S17) S97) +(declare-fun f152 (S11 S21) S96) +(declare-fun f153 (S98) S6) +(declare-fun f154 (S99 S18) Int) +(declare-fun f155 () S99) +(declare-fun f156 (S98 S8) S18) +(declare-fun f157 (S100) S11) +(declare-fun f158 (S100 S3) S18) +(declare-fun f159 (S101) S15) +(declare-fun f160 (S101 Int) S18) +(declare-fun f161 (S102) S16) +(declare-fun f162 (S102 S18) S18) +(declare-fun f163 (S103) S21) +(declare-fun f164 (S103 S17) S18) +(declare-fun f165 (S104 S6) S6) +(declare-fun f166 (S98) S104) +(declare-fun f167 (S105 S11) S11) +(declare-fun f168 (S100) S105) +(declare-fun f169 (S106 S15) S15) +(declare-fun f170 (S101) S106) +(declare-fun f171 (S107 S16) S16) +(declare-fun f172 (S102) S107) +(declare-fun f173 (S108 S21) S21) +(declare-fun f174 (S103) S108) +(declare-fun f175 (S15 S11) S1) +(declare-fun f176 (S6 S33) S1) +(declare-fun f177 (S11 S37) S1) +(declare-fun f178 (S26 S15) S1) +(declare-fun f179 (Int S26) S1) +(declare-fun f180 (S21 S6) S1) +(declare-fun f181 (S28 S16) S1) +(declare-fun f182 (S18 S28) S1) +(declare-fun f183 (S16 S21) S1) +(declare-fun f184 () S109) +(declare-fun f185 () S109) +(declare-fun f186 () S110) +(declare-fun f187 () S110) +(declare-fun f188 () S111) +(declare-fun f189 () S111) +(declare-fun f190 (S113 S112) S15) +(declare-fun f191 (S6) S113) +(declare-fun f192 (S112 Int) S8) +(declare-fun f193 (S114 S4) S15) +(declare-fun f194 (S11) S114) +(declare-fun f195 (S116 S115) S15) +(declare-fun f196 (S15) S116) +(declare-fun f197 (S115 Int) Int) +(declare-fun f198 (S118 S117) S6) +(declare-fun f199 (S15) S118) +(declare-fun f200 (S117 S8) Int) +(declare-fun f201 (S119 S2) S11) +(declare-fun f202 (S15) S119) +(declare-fun f203 (S120 S99) S16) +(declare-fun f204 (S15) S120) +(declare-fun f205 (S122 S121) S16) +(declare-fun f206 (S6) S122) +(declare-fun f207 (S121 S18) S8) +(declare-fun f208 (S124 S123) S16) +(declare-fun f209 (S11) S124) +(declare-fun f210 (S123 S18) S3) +(declare-fun f211 (S126 S125) S21) +(declare-fun f212 (S15) S126) +(declare-fun f213 (S125 S17) Int) +(declare-fun f214 (S127 S22) S21) +(declare-fun f215 (S6) S127) +(declare-fun f216 (S129 S128) S21) +(declare-fun f217 (S11) S129) +(declare-fun f218 (S128 S17) S3) +(declare-fun f219 (S130 S101) S15) +(declare-fun f220 (S16) S130) +(declare-fun f221 (S131 S98) S6) +(declare-fun f222 (S16) S131) +(declare-fun f223 (S132 S100) S11) +(declare-fun f224 (S16) S132) +(declare-fun f225 (S134 S133) S15) +(declare-fun f226 (S21) S134) +(declare-fun f227 (S133 Int) S17) +(declare-fun f228 (S136 S135) S6) +(declare-fun f229 (S21) S136) +(declare-fun f230 (S135 S8) S17) +(declare-fun f231 (S138 S137) S11) +(declare-fun f232 (S21) S138) +(declare-fun f233 (S137 S3) S17) +(declare-fun f234 (S24) S6) +(declare-fun f235 (S25) S11) +(declare-fun f236 (S111 S27) S15) +(declare-fun f237 (S110 S29) S16) +(declare-fun f238 (S109 S30) S21) +(declare-fun f239 (S139 Int) S39) +(declare-fun f240 (S139) S25) +(declare-fun f241 (S141 Int) S6) +(declare-fun f242 (S140 Int) S141) +(declare-fun f243 (S142 S3) S6) +(declare-fun f244 (S140) S142) +(declare-fun f245 (S144 Int) S11) +(declare-fun f246 (S143 Int) S144) +(declare-fun f247 (S143) S35) +(declare-fun f248 (S146 Int) S28) +(declare-fun f249 (S145 Int) S146) +(declare-fun f250 (S147 S3) S28) +(declare-fun f251 (S145) S147) +(declare-fun f252 (S148 Int) S27) +(declare-fun f253 (S149 S3) S26) +(declare-fun f254 (S148) S149) +(declare-fun f255 (S151 S18) S15) +(declare-fun f256 (S150 S18) S151) +(declare-fun f257 (S152 S17) S15) +(declare-fun f258 (S150) S152) +(declare-fun f259 (S154 S18) S6) +(declare-fun f260 (S153 S18) S154) +(declare-fun f261 (S155 S17) S6) +(declare-fun f262 (S153) S155) +(declare-fun f263 (S157 S18) S11) +(declare-fun f264 (S156 S18) S157) +(declare-fun f265 (S158 S17) S11) +(declare-fun f266 (S156) S158) +(declare-fun f267 (S159 S18) S29) +(declare-fun f268 (S160 S17) S28) +(declare-fun f269 (S159) S160) +(declare-fun f270 (S162 S18) S26) +(declare-fun f271 (S161 S18) S162) +(declare-fun f272 (S163 S17) S26) +(declare-fun f273 (S161) S163) +(declare-fun f274 (S164 S17) S152) +(declare-fun f275 (S165 S8) S15) +(declare-fun f276 (S164) S165) +(declare-fun f277 (S166 S17) S155) +(declare-fun f278 (S166) S31) +(declare-fun f279 (S167 S17) S158) +(declare-fun f280 (S168 S8) S11) +(declare-fun f281 (S167) S168) +(declare-fun f282 (S169 S17) S160) +(declare-fun f283 (S170 S8) S28) +(declare-fun f284 (S169) S170) +(declare-fun f285 (S171 S17) S163) +(declare-fun f286 (S172 S8) S26) +(declare-fun f287 (S171) S172) +(declare-fun f288 (S174 S8) S16) +(declare-fun f289 (S173 S8) S174) +(declare-fun f290 (S175 S7) S16) +(declare-fun f291 (S173) S175) +(declare-fun f292 (S177 S3) S16) +(declare-fun f293 (S176 S3) S177) +(declare-fun f294 (S178 S12) S16) +(declare-fun f295 (S176) S178) +(declare-fun f296 (S179 S8) S24) +(declare-fun f297 (S180 S7) S21) +(declare-fun f298 (S179) S180) +(declare-fun f299 (S182 S3) S21) +(declare-fun f300 (S181 S3) S182) +(declare-fun f301 (S183 S12) S21) +(declare-fun f302 (S181) S183) +(declare-fun f303 () S16) +(declare-fun f304 () S21) +(declare-fun f305 (S16) S1) +(declare-fun f306 (S21) S1) +(declare-fun f307 (S16) S1) +(declare-fun f308 (S21) S1) +(declare-fun f309 (S16) S1) +(declare-fun f310 (S15) S1) +(declare-fun f311 (S21) S1) +(declare-fun f312 (S15) S1) +(declare-fun f313 (S15) S1) +(declare-fun f314 (S6) S1) +(declare-fun f315 () S101) +(declare-fun f316 (S30) S1) +(declare-fun f317 (S29) S1) +(declare-fun f318 (S24) S1) +(declare-fun f319 () S16) +(declare-fun f320 () S21) +(declare-fun f321 (S184) S1) +(declare-fun f322 (S21) S184) +(declare-fun f323 (S185) S1) +(declare-fun f324 (S16) S185) +(declare-fun f325 (S16) S16) +(declare-fun f326 (S21) S21) +(declare-fun f327 (S15) S15) +(declare-fun f328 (S21) S184) +(declare-fun f329 (S16) S185) +(declare-fun f330 (S6) S6) +(declare-fun f331 (S11) S11) +(assert (not (= f1 f2))) +(assert (not (= (f3 (* f4 f5)) f1))) +(assert (= (f3 f4) f1)) +(assert (= (f3 f5) f1)) +(assert (forall ((?v0 Int)) (= (= (f3 ?v0) f1) (exists ((?v1 Int) (?v2 Int)) (= (f6 f7 (f8 (f9 f10 ?v1) ?v2)) ?v0))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (* (f6 f7 (f8 (f9 f10 ?v0) ?v1)) (f6 f7 (f8 (f9 f10 ?v2) ?v3))) (f6 f7 (f8 (f9 f10 (+ (* ?v0 ?v2) (* ?v1 ?v3))) (- (* ?v0 ?v3) (* ?v1 ?v2))))))) +(assert (forall ((?v0 S6)) (= (forall ((?v1 S7)) (= (f11 ?v0 ?v1) f1)) (forall ((?v1 S8) (?v2 S8)) (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S11)) (= (forall ((?v1 S12)) (= (f15 ?v0 ?v1) f1)) (forall ((?v1 S3) (?v2 S3)) (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S15)) (= (forall ((?v1 S3)) (= (f19 ?v0 ?v1) f1)) (forall ((?v1 Int) (?v2 Int)) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S16)) (= (forall ((?v1 S17)) (= (f20 ?v0 ?v1) f1)) (forall ((?v1 S18) (?v2 S18)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S21)) (= (forall ((?v1 S8)) (= (f24 ?v0 ?v1) f1)) (forall ((?v1 S17) (?v2 S17)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S8) (?v3 S8)) (= (= (f12 (f13 f14 ?v0) ?v1) (f12 (f13 f14 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (= (= (f16 (f17 f18 ?v0) ?v1) (f16 (f17 f18 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (= (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (= (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17)) (= (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S8) (?v3 S8)) (=> (= (f12 (f13 f14 ?v0) ?v1) (f12 (f13 f14 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3)) (=> (= (f16 (f17 f18 ?v0) ?v1) (f16 (f17 f18 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int)) (=> (= (f8 (f9 f10 ?v0) ?v1) (f8 (f9 f10 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (= (f21 (f22 f23 ?v0) ?v1) (f21 (f22 f23 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17)) (=> (= (f25 (f26 f27 ?v0) ?v1) (f25 (f26 f27 ?v2) ?v3)) (=> (=> (= ?v0 ?v2) (=> (= ?v1 ?v3) false)) false)))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (= (= (f24 (f28 (f29 ?v0) ?v1) ?v2) f1) (= (f30 (f12 (f13 f14 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (= (= (f19 (f31 (f32 ?v0) ?v1) ?v2) f1) (= (f33 (f16 (f17 f18 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (= (= (f34 (f35 (f36 ?v0) ?v1) ?v2) f1) (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (= (= (f38 (f39 (f40 ?v0) ?v1) ?v2) f1) (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (= (= (f20 (f42 (f43 ?v0) ?v1) ?v2) f1) (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S8) (?v2 S8) (?v3 S8) (?v4 S31)) (let ((?v_0 (f13 f14 ?v1))) (=> (= (f24 ?v0 ?v1) f1) (=> (= (f30 (f12 (f13 f14 ?v2) ?v3) (f45 ?v4 ?v1)) f1) (= (f46 (f47 (f12 ?v_0 ?v2) (f12 ?v_0 ?v3)) (f48 (f49 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S15) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S35)) (let ((?v_0 (f17 f18 ?v1))) (=> (= (f19 ?v0 ?v1) f1) (=> (= (f33 (f16 (f17 f18 ?v2) ?v3) (f50 ?v4 ?v1)) f1) (= (f51 (f52 (f16 ?v_0 ?v2) (f16 ?v_0 ?v3)) (f53 (f54 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S26) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S39)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f34 ?v0 ?v1) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) (f55 ?v4 ?v1)) f1) (= (f33 (f16 (f17 f18 (f8 ?v_0 ?v2)) (f8 ?v_0 ?v3)) (f56 (f57 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S16) (?v1 S17) (?v2 S17) (?v3 S17) (?v4 S41)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f20 ?v0 ?v1) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) (f58 ?v4 ?v1)) f1) (= (f30 (f12 (f13 f14 (f25 ?v_0 ?v2)) (f25 ?v_0 ?v3)) (f59 (f60 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S28) (?v1 S18) (?v2 S18) (?v3 S18) (?v4 S43)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f38 ?v0 ?v1) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) (f61 ?v4 ?v1)) f1) (= (f44 (f25 (f26 f27 (f21 ?v_0 ?v2)) (f21 ?v_0 ?v3)) (f62 (f63 ?v0) ?v4)) f1)))))) +(assert (forall ((?v0 S6)) (= (= (f64 ?v0) f1) (forall ((?v1 S8)) (= (f30 (f12 (f13 f14 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S11)) (= (= (f65 ?v0) f1) (forall ((?v1 S3)) (= (f33 (f16 (f17 f18 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S15)) (= (= (f66 ?v0) f1) (forall ((?v1 Int)) (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S16)) (= (= (f67 ?v0) f1) (forall ((?v1 S18)) (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S21)) (= (= (f68 ?v0) f1) (forall ((?v1 S17)) (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S6)) (= (= (f69 ?v0) f1) (forall ((?v1 S8)) (not (= (f30 (f12 (f13 f14 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S11)) (= (= (f70 ?v0) f1) (forall ((?v1 S3)) (not (= (f33 (f16 (f17 f18 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S15)) (= (= (f71 ?v0) f1) (forall ((?v1 Int)) (not (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S16)) (= (= (f72 ?v0) f1) (forall ((?v1 S18)) (not (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S21)) (= (= (f73 ?v0) f1) (forall ((?v1 S17)) (not (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S6)) (= (exists ((?v1 S7)) (= (f11 ?v0 ?v1) f1)) (exists ((?v1 S8) (?v2 S8)) (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S11)) (= (exists ((?v1 S12)) (= (f15 ?v0 ?v1) f1)) (exists ((?v1 S3) (?v2 S3)) (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S15)) (= (exists ((?v1 S3)) (= (f19 ?v0 ?v1) f1)) (exists ((?v1 Int) (?v2 Int)) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S16)) (= (exists ((?v1 S17)) (= (f20 ?v0 ?v1) f1)) (exists ((?v1 S18) (?v2 S18)) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S21)) (= (exists ((?v1 S8)) (= (f24 ?v0 ?v1) f1)) (exists ((?v1 S17) (?v2 S17)) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1))))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S17) (?v3 S18) (?v4 S18)) (=> (= ?v0 (f12 (f13 f14 ?v1) (f25 (f26 f27 ?v2) (f21 (f22 f23 ?v3) ?v4)))) false)) false))) +(assert (forall ((?v0 S6) (?v1 S7)) (=> (forall ((?v2 S8) (?v3 S17) (?v4 S18) (?v5 S18)) (= (f11 ?v0 (f12 (f13 f14 ?v2) (f25 (f26 f27 ?v3) (f21 (f22 f23 ?v4) ?v5)))) f1)) (= (f11 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S17) (?v2 S18) (?v3 S18)) (=> (= ?v0 (f25 (f26 f27 ?v1) (f21 (f22 f23 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S12)) (=> (forall ((?v1 S3) (?v2 Int) (?v3 Int)) (=> (= ?v0 (f16 (f17 f18 ?v1) (f8 (f9 f10 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S17) (?v3 S17)) (=> (= ?v0 (f12 (f13 f14 ?v1) (f25 (f26 f27 ?v2) ?v3))) false)) false))) +(assert (forall ((?v0 S21) (?v1 S8)) (=> (forall ((?v2 S17) (?v3 S18) (?v4 S18)) (= (f24 ?v0 (f25 (f26 f27 ?v2) (f21 (f22 f23 ?v3) ?v4))) f1)) (= (f24 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S11) (?v1 S12)) (=> (forall ((?v2 S3) (?v3 Int) (?v4 Int)) (= (f15 ?v0 (f16 (f17 f18 ?v2) (f8 (f9 f10 ?v3) ?v4))) f1)) (= (f15 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S6) (?v1 S7)) (=> (forall ((?v2 S8) (?v3 S17) (?v4 S17)) (= (f11 ?v0 (f12 (f13 f14 ?v2) (f25 (f26 f27 ?v3) ?v4))) f1)) (= (f11 ?v0 ?v1) f1)))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S8)) (=> (= ?v0 (f12 (f13 f14 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S12)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f16 (f17 f18 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S17)) (=> (forall ((?v1 S18) (?v2 S18)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S17) (?v2 S17)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S7)) (=> (forall ((?v1 S8) (?v2 S8)) (=> (= ?v0 (f12 (f13 f14 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S12)) (=> (forall ((?v1 S3) (?v2 S3)) (=> (= ?v0 (f16 (f17 f18 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S3)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= ?v0 (f8 (f9 f10 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S17)) (=> (forall ((?v1 S18) (?v2 S18)) (=> (= ?v0 (f21 (f22 f23 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S8)) (=> (forall ((?v1 S17) (?v2 S17)) (=> (= ?v0 (f25 (f26 f27 ?v1) ?v2)) false)) false))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (=> (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1) (= (f24 (f28 (f74 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (=> (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1) (= (f19 (f31 (f75 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S8) (?v3 S8) (?v4 S6) (?v5 S6)) (let ((?v_0 (f13 f14 ?v0))) (= (= (f46 (f47 (f12 ?v_0 ?v1) (f12 (f13 f14 ?v2) ?v3)) (f79 (f80 ?v4) ?v5)) f1) (or (= (f30 (f12 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S3) (?v3 S3) (?v4 S11) (?v5 S11)) (let ((?v_0 (f17 f18 ?v0))) (= (= (f51 (f52 (f16 ?v_0 ?v1) (f16 (f17 f18 ?v2) ?v3)) (f81 (f82 ?v4) ?v5)) f1) (or (= (f33 (f16 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S15) (?v5 S15)) (let ((?v_0 (f9 f10 ?v0))) (= (= (f33 (f16 (f17 f18 (f8 ?v_0 ?v1)) (f8 (f9 f10 ?v2) ?v3)) (f83 (f84 ?v4) ?v5)) f1) (or (= (f37 (f8 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17) (?v4 S21) (?v5 S21)) (let ((?v_0 (f26 f27 ?v0))) (= (= (f30 (f12 (f13 f14 (f25 ?v_0 ?v1)) (f25 (f26 f27 ?v2) ?v3)) (f85 (f86 ?v4) ?v5)) f1) (or (= (f44 (f25 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 Int) (?v1 S8) (?v2 Int) (?v3 S8) (?v4 S15) (?v5 S6)) (= (= (f87 (f88 (f89 ?v0 ?v1) (f89 ?v2 ?v3)) (f90 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S3) (?v2 Int) (?v3 S3) (?v4 S15) (?v5 S11)) (= (= (f91 (f92 (f93 ?v0 ?v1) (f93 ?v2 ?v3)) (f94 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S8) (?v1 Int) (?v2 S8) (?v3 Int) (?v4 S6) (?v5 S15)) (= (= (f95 (f96 (f97 ?v0 ?v1) (f97 ?v2 ?v3)) (f98 ?v4 ?v5)) f1) (or (= (f30 (f12 (f13 f14 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 Int) (?v2 S3) (?v3 Int) (?v4 S11) (?v5 S15)) (= (= (f99 (f100 (f101 ?v0 ?v1) (f101 ?v2 ?v3)) (f102 ?v4 ?v5)) f1) (or (= (f33 (f16 (f17 f18 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18) (?v4 S16) (?v5 S16)) (let ((?v_0 (f22 f23 ?v0))) (= (= (f44 (f25 (f26 f27 (f21 ?v_0 ?v1)) (f21 (f22 f23 ?v2) ?v3)) (f103 (f104 ?v4) ?v5)) f1) (or (= (f41 (f21 ?v_0 ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1))))))) +(assert (forall ((?v0 S18) (?v1 Int) (?v2 S18) (?v3 Int) (?v4 S16) (?v5 S15)) (= (= (f105 (f106 (f107 ?v0 ?v1) (f107 ?v2 ?v3)) (f108 ?v4 ?v5)) f1) (or (= (f41 (f21 (f22 f23 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S18) (?v1 S8) (?v2 S18) (?v3 S8) (?v4 S16) (?v5 S6)) (= (= (f109 (f110 (f111 ?v0 ?v1) (f111 ?v2 ?v3)) (f112 ?v4 ?v5)) f1) (or (= (f41 (f21 (f22 f23 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S18) (?v1 S3) (?v2 S18) (?v3 S3) (?v4 S16) (?v5 S11)) (= (= (f113 (f114 (f115 ?v0 ?v1) (f115 ?v2 ?v3)) (f116 ?v4 ?v5)) f1) (or (= (f41 (f21 (f22 f23 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S17) (?v1 Int) (?v2 S17) (?v3 Int) (?v4 S21) (?v5 S15)) (= (= (f117 (f118 (f119 ?v0 ?v1) (f119 ?v2 ?v3)) (f120 ?v4 ?v5)) f1) (or (= (f44 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S17) (?v1 S8) (?v2 S17) (?v3 S8) (?v4 S21) (?v5 S6)) (= (= (f121 (f122 (f123 ?v0 ?v1) (f123 ?v2 ?v3)) (f124 ?v4 ?v5)) f1) (or (= (f44 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f30 (f12 (f13 f14 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S17) (?v1 S3) (?v2 S17) (?v3 S3) (?v4 S21) (?v5 S11)) (= (= (f125 (f126 (f127 ?v0 ?v1) (f127 ?v2 ?v3)) (f128 ?v4 ?v5)) f1) (or (= (f44 (f25 (f26 f27 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f33 (f16 (f17 f18 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S18) (?v2 Int) (?v3 S18) (?v4 S15) (?v5 S16)) (= (= (f129 (f130 (f131 ?v0 ?v1) (f131 ?v2 ?v3)) (f132 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S8) (?v1 S18) (?v2 S8) (?v3 S18) (?v4 S6) (?v5 S16)) (= (= (f133 (f134 (f135 ?v0 ?v1) (f135 ?v2 ?v3)) (f136 ?v4 ?v5)) f1) (or (= (f30 (f12 (f13 f14 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 S18) (?v2 S3) (?v3 S18) (?v4 S11) (?v5 S16)) (= (= (f137 (f138 (f139 ?v0 ?v1) (f139 ?v2 ?v3)) (f140 ?v4 ?v5)) f1) (or (= (f33 (f16 (f17 f18 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 Int) (?v1 S17) (?v2 Int) (?v3 S17) (?v4 S15) (?v5 S21)) (= (= (f141 (f142 (f143 ?v0 ?v1) (f143 ?v2 ?v3)) (f144 ?v4 ?v5)) f1) (or (= (f37 (f8 (f9 f10 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S8) (?v1 S17) (?v2 S8) (?v3 S17) (?v4 S6) (?v5 S21)) (= (= (f145 (f146 (f147 ?v0 ?v1) (f147 ?v2 ?v3)) (f148 ?v4 ?v5)) f1) (or (= (f30 (f12 (f13 f14 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S3) (?v1 S17) (?v2 S3) (?v3 S17) (?v4 S11) (?v5 S21)) (= (= (f149 (f150 (f151 ?v0 ?v1) (f151 ?v2 ?v3)) (f152 ?v4 ?v5)) f1) (or (= (f33 (f16 (f17 f18 ?v0) ?v2) ?v4) f1) (and (= ?v0 ?v2) (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v5) f1)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (= (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (= (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (= (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 (f74 ?v0) ?v1) ?v2) f1) (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 (f75 ?v0) ?v1) ?v2) f1) (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1) (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1) (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1) (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 (f74 ?v0) ?v1) ?v2) f1) (=> (=> (= (f11 ?v0 (f12 (f13 f14 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S11) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 (f75 ?v0) ?v1) ?v2) f1) (=> (=> (= (f15 ?v0 (f16 (f17 f18 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 (f76 ?v0) ?v1) ?v2) f1) (=> (=> (= (f19 ?v0 (f8 (f9 f10 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 (f77 ?v0) ?v1) ?v2) f1) (=> (=> (= (f20 ?v0 (f21 (f22 f23 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 (f78 ?v0) ?v1) ?v2) f1) (=> (=> (= (f24 ?v0 (f25 (f26 f27 ?v1) ?v2)) f1) false) false)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S98)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f153 ?v2)) f1) (< (f154 f155 (f156 ?v2 ?v0)) (f154 f155 (f156 ?v2 ?v1)))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S100)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f157 ?v2)) f1) (< (f154 f155 (f158 ?v2 ?v0)) (f154 f155 (f158 ?v2 ?v1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S101)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f159 ?v2)) f1) (< (f154 f155 (f160 ?v2 ?v0)) (f154 f155 (f160 ?v2 ?v1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S102)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f161 ?v2)) f1) (< (f154 f155 (f162 ?v2 ?v0)) (f154 f155 (f162 ?v2 ?v1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S103)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f163 ?v2)) f1) (< (f154 f155 (f164 ?v2 ?v0)) (f154 f155 (f164 ?v2 ?v1)))))) +(assert (forall ((?v0 S98) (?v1 S8) (?v2 S8) (?v3 S6)) (=> (< (f154 f155 (f156 ?v0 ?v1)) (f154 f155 (f156 ?v0 ?v2))) (= (f30 (f12 (f13 f14 ?v1) ?v2) (f165 (f166 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S100) (?v1 S3) (?v2 S3) (?v3 S11)) (=> (< (f154 f155 (f158 ?v0 ?v1)) (f154 f155 (f158 ?v0 ?v2))) (= (f33 (f16 (f17 f18 ?v1) ?v2) (f167 (f168 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S101) (?v1 Int) (?v2 Int) (?v3 S15)) (=> (< (f154 f155 (f160 ?v0 ?v1)) (f154 f155 (f160 ?v0 ?v2))) (= (f37 (f8 (f9 f10 ?v1) ?v2) (f169 (f170 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S102) (?v1 S18) (?v2 S18) (?v3 S16)) (=> (< (f154 f155 (f162 ?v0 ?v1)) (f154 f155 (f162 ?v0 ?v2))) (= (f41 (f21 (f22 f23 ?v1) ?v2) (f171 (f172 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S103) (?v1 S17) (?v2 S17) (?v3 S21)) (=> (< (f154 f155 (f164 ?v0 ?v1)) (f154 f155 (f164 ?v0 ?v2))) (= (f44 (f25 (f26 f27 ?v1) ?v2) (f173 (f174 ?v0) ?v3)) f1)))) +(assert (forall ((?v0 S98) (?v1 S8) (?v2 S8) (?v3 S6)) (let ((?v_0 (f12 (f13 f14 ?v1) ?v2))) (=> (<= (f154 f155 (f156 ?v0 ?v1)) (f154 f155 (f156 ?v0 ?v2))) (=> (= (f30 ?v_0 ?v3) f1) (= (f30 ?v_0 (f165 (f166 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S100) (?v1 S3) (?v2 S3) (?v3 S11)) (let ((?v_0 (f16 (f17 f18 ?v1) ?v2))) (=> (<= (f154 f155 (f158 ?v0 ?v1)) (f154 f155 (f158 ?v0 ?v2))) (=> (= (f33 ?v_0 ?v3) f1) (= (f33 ?v_0 (f167 (f168 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S101) (?v1 Int) (?v2 Int) (?v3 S15)) (let ((?v_0 (f8 (f9 f10 ?v1) ?v2))) (=> (<= (f154 f155 (f160 ?v0 ?v1)) (f154 f155 (f160 ?v0 ?v2))) (=> (= (f37 ?v_0 ?v3) f1) (= (f37 ?v_0 (f169 (f170 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S102) (?v1 S18) (?v2 S18) (?v3 S16)) (let ((?v_0 (f21 (f22 f23 ?v1) ?v2))) (=> (<= (f154 f155 (f162 ?v0 ?v1)) (f154 f155 (f162 ?v0 ?v2))) (=> (= (f41 ?v_0 ?v3) f1) (= (f41 ?v_0 (f171 (f172 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S103) (?v1 S17) (?v2 S17) (?v3 S21)) (let ((?v_0 (f25 (f26 f27 ?v1) ?v2))) (=> (<= (f154 f155 (f164 ?v0 ?v1)) (f154 f155 (f164 ?v0 ?v2))) (=> (= (f44 ?v_0 ?v3) f1) (= (f44 ?v_0 (f173 (f174 ?v0) ?v3)) f1)))))) +(assert (forall ((?v0 S15) (?v1 S11)) (= (= (f175 ?v0 ?v1) f1) (forall ((?v2 S3)) (=> (= (f37 ?v2 ?v0) f1) (forall ((?v3 S3)) (=> (= (f37 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f33 (f16 (f17 f18 ?v2) ?v3) ?v1) f1) (= (f33 (f16 (f17 f18 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S6) (?v1 S33)) (= (= (f176 ?v0 ?v1) f1) (forall ((?v2 S7)) (=> (= (f30 ?v2 ?v0) f1) (forall ((?v3 S7)) (=> (= (f30 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f46 (f47 ?v2 ?v3) ?v1) f1) (= (f46 (f47 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S11) (?v1 S37)) (= (= (f177 ?v0 ?v1) f1) (forall ((?v2 S12)) (=> (= (f33 ?v2 ?v0) f1) (forall ((?v3 S12)) (=> (= (f33 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f51 (f52 ?v2 ?v3) ?v1) f1) (= (f51 (f52 ?v3 ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S26) (?v1 S15)) (= (= (f178 ?v0 ?v1) f1) (forall ((?v2 Int)) (=> (= (f179 ?v2 ?v0) f1) (forall ((?v3 Int)) (=> (= (f179 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v1) f1) (= (f37 (f8 (f9 f10 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S21) (?v1 S6)) (= (= (f180 ?v0 ?v1) f1) (forall ((?v2 S8)) (=> (= (f44 ?v2 ?v0) f1) (forall ((?v3 S8)) (=> (= (f44 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f30 (f12 (f13 f14 ?v2) ?v3) ?v1) f1) (= (f30 (f12 (f13 f14 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S28) (?v1 S16)) (= (= (f181 ?v0 ?v1) f1) (forall ((?v2 S18)) (=> (= (f182 ?v2 ?v0) f1) (forall ((?v3 S18)) (=> (= (f182 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v1) f1) (= (f41 (f21 (f22 f23 ?v3) ?v2) ?v1) f1)))))))))) +(assert (forall ((?v0 S16) (?v1 S21)) (= (= (f183 ?v0 ?v1) f1) (forall ((?v2 S17)) (=> (= (f41 ?v2 ?v0) f1) (forall ((?v3 S17)) (=> (= (f41 ?v3 ?v0) f1) (=> (not (= ?v2 ?v3)) (or (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v1) f1) (= (f44 (f25 (f26 f27 ?v3) ?v2) ?v1) f1)))))))))) +(assert (= f184 f185)) +(assert (= f186 f187)) +(assert (= f188 f189)) +(assert (forall ((?v0 S7)) (exists ((?v1 S8) (?v2 S8)) (= ?v0 (f12 (f13 f14 ?v1) ?v2))))) +(assert (forall ((?v0 S12)) (exists ((?v1 S3) (?v2 S3)) (= ?v0 (f16 (f17 f18 ?v1) ?v2))))) +(assert (forall ((?v0 S3)) (exists ((?v1 Int) (?v2 Int)) (= ?v0 (f8 (f9 f10 ?v1) ?v2))))) +(assert (forall ((?v0 S17)) (exists ((?v1 S18) (?v2 S18)) (= ?v0 (f21 (f22 f23 ?v1) ?v2))))) +(assert (forall ((?v0 S8)) (exists ((?v1 S17) (?v2 S17)) (= ?v0 (f25 (f26 f27 ?v1) ?v2))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S6) (?v3 S112)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f190 (f191 ?v2) ?v3)) f1) (= (f30 (f12 (f13 f14 (f192 ?v3 ?v0)) (f192 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S11) (?v3 S4)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f193 (f194 ?v2) ?v3)) f1) (= (f33 (f16 (f17 f18 (f8 ?v3 ?v0)) (f8 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 S115)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f195 (f196 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f197 ?v3 ?v0)) (f197 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S15) (?v3 S117)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f198 (f199 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f200 ?v3 ?v0)) (f200 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S15) (?v3 S2)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f201 (f202 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f6 ?v3 ?v0)) (f6 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S15) (?v3 S99)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f203 (f204 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f154 ?v3 ?v0)) (f154 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S6) (?v3 S121)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f205 (f206 ?v2) ?v3)) f1) (= (f30 (f12 (f13 f14 (f207 ?v3 ?v0)) (f207 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S11) (?v3 S123)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f208 (f209 ?v2) ?v3)) f1) (= (f33 (f16 (f17 f18 (f210 ?v3 ?v0)) (f210 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S15) (?v3 S125)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f211 (f212 ?v2) ?v3)) f1) (= (f37 (f8 (f9 f10 (f213 ?v3 ?v0)) (f213 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S6) (?v3 S22)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f214 (f215 ?v2) ?v3)) f1) (= (f30 (f12 (f13 f14 (f25 ?v3 ?v0)) (f25 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S11) (?v3 S128)) (= (= (f44 (f25 (f26 f27 ?v0) ?v1) (f216 (f217 ?v2) ?v3)) f1) (= (f33 (f16 (f17 f18 (f218 ?v3 ?v0)) (f218 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S16) (?v3 S101)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f219 (f220 ?v2) ?v3)) f1) (= (f41 (f21 (f22 f23 (f160 ?v3 ?v0)) (f160 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S16) (?v3 S98)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f221 (f222 ?v2) ?v3)) f1) (= (f41 (f21 (f22 f23 (f156 ?v3 ?v0)) (f156 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S16) (?v3 S100)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f223 (f224 ?v2) ?v3)) f1) (= (f41 (f21 (f22 f23 (f158 ?v3 ?v0)) (f158 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S21) (?v3 S133)) (= (= (f37 (f8 (f9 f10 ?v0) ?v1) (f225 (f226 ?v2) ?v3)) f1) (= (f44 (f25 (f26 f27 (f227 ?v3 ?v0)) (f227 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S21) (?v3 S135)) (= (= (f30 (f12 (f13 f14 ?v0) ?v1) (f228 (f229 ?v2) ?v3)) f1) (= (f44 (f25 (f26 f27 (f230 ?v3 ?v0)) (f230 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S21) (?v3 S137)) (= (= (f33 (f16 (f17 f18 ?v0) ?v1) (f231 (f232 ?v2) ?v3)) f1) (= (f44 (f25 (f26 f27 (f233 ?v3 ?v0)) (f233 ?v3 ?v1)) ?v2) f1)))) +(assert (forall ((?v0 S24) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 ?v0 ?v1) ?v2) f1) (= (f11 (f234 ?v0) (f12 (f13 f14 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 ?v0 ?v1) ?v2) f1) (= (f15 (f235 ?v0) (f16 (f17 f18 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 ?v0 ?v1) ?v2) f1) (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 ?v0 ?v1) ?v2) f1) (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 ?v0 ?v1) ?v2) f1) (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S24) (?v1 S8) (?v2 S8)) (=> (= (f24 (f28 ?v0 ?v1) ?v2) f1) (= (f11 (f234 ?v0) (f12 (f13 f14 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 S3)) (=> (= (f19 (f31 ?v0 ?v1) ?v2) f1) (= (f15 (f235 ?v0) (f16 (f17 f18 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (=> (= (f34 (f35 ?v0 ?v1) ?v2) f1) (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (=> (= (f38 (f39 ?v0 ?v1) ?v2) f1) (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (=> (= (f20 (f42 ?v0 ?v1) ?v2) f1) (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1)))) +(assert (forall ((?v0 S3) (?v1 S139) (?v2 Int) (?v3 Int)) (=> (= (f37 ?v0 (f55 (f239 ?v1 ?v2) ?v3)) f1) (= (f37 ?v0 (f31 (f240 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S7) (?v1 S140) (?v2 Int) (?v3 Int)) (=> (= (f30 ?v0 (f241 (f242 ?v1 ?v2) ?v3)) f1) (= (f30 ?v0 (f243 (f244 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S12) (?v1 S143) (?v2 Int) (?v3 Int)) (=> (= (f33 ?v0 (f245 (f246 ?v1 ?v2) ?v3)) f1) (= (f33 ?v0 (f50 (f247 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S18) (?v1 S145) (?v2 Int) (?v3 Int)) (=> (= (f182 ?v0 (f248 (f249 ?v1 ?v2) ?v3)) f1) (= (f182 ?v0 (f250 (f251 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 Int) (?v1 S148) (?v2 Int) (?v3 Int)) (=> (= (f179 ?v0 (f35 (f252 ?v1 ?v2) ?v3)) f1) (= (f179 ?v0 (f253 (f254 ?v1) (f8 (f9 f10 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S3) (?v1 S150) (?v2 S18) (?v3 S18)) (=> (= (f37 ?v0 (f255 (f256 ?v1 ?v2) ?v3)) f1) (= (f37 ?v0 (f257 (f258 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S7) (?v1 S153) (?v2 S18) (?v3 S18)) (=> (= (f30 ?v0 (f259 (f260 ?v1 ?v2) ?v3)) f1) (= (f30 ?v0 (f261 (f262 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S12) (?v1 S156) (?v2 S18) (?v3 S18)) (=> (= (f33 ?v0 (f263 (f264 ?v1 ?v2) ?v3)) f1) (= (f33 ?v0 (f265 (f266 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S18) (?v1 S159) (?v2 S18) (?v3 S18)) (=> (= (f182 ?v0 (f39 (f267 ?v1 ?v2) ?v3)) f1) (= (f182 ?v0 (f268 (f269 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 Int) (?v1 S161) (?v2 S18) (?v3 S18)) (=> (= (f179 ?v0 (f270 (f271 ?v1 ?v2) ?v3)) f1) (= (f179 ?v0 (f272 (f273 ?v1) (f21 (f22 f23 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S3) (?v1 S164) (?v2 S17) (?v3 S17)) (=> (= (f37 ?v0 (f257 (f274 ?v1 ?v2) ?v3)) f1) (= (f37 ?v0 (f275 (f276 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S7) (?v1 S166) (?v2 S17) (?v3 S17)) (=> (= (f30 ?v0 (f261 (f277 ?v1 ?v2) ?v3)) f1) (= (f30 ?v0 (f45 (f278 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S12) (?v1 S167) (?v2 S17) (?v3 S17)) (=> (= (f33 ?v0 (f265 (f279 ?v1 ?v2) ?v3)) f1) (= (f33 ?v0 (f280 (f281 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S18) (?v1 S169) (?v2 S17) (?v3 S17)) (=> (= (f182 ?v0 (f268 (f282 ?v1 ?v2) ?v3)) f1) (= (f182 ?v0 (f283 (f284 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 Int) (?v1 S171) (?v2 S17) (?v3 S17)) (=> (= (f179 ?v0 (f272 (f285 ?v1 ?v2) ?v3)) f1) (= (f179 ?v0 (f286 (f287 ?v1) (f25 (f26 f27 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S17) (?v1 S173) (?v2 S8) (?v3 S8)) (=> (= (f41 ?v0 (f288 (f289 ?v1 ?v2) ?v3)) f1) (= (f41 ?v0 (f290 (f291 ?v1) (f12 (f13 f14 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S17) (?v1 S176) (?v2 S3) (?v3 S3)) (=> (= (f41 ?v0 (f292 (f293 ?v1 ?v2) ?v3)) f1) (= (f41 ?v0 (f294 (f295 ?v1) (f16 (f17 f18 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S8) (?v1 S179) (?v2 S8) (?v3 S8)) (=> (= (f44 ?v0 (f28 (f296 ?v1 ?v2) ?v3)) f1) (= (f44 ?v0 (f297 (f298 ?v1) (f12 (f13 f14 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S8) (?v1 S181) (?v2 S3) (?v3 S3)) (=> (= (f44 ?v0 (f299 (f300 ?v1 ?v2) ?v3)) f1) (= (f44 ?v0 (f301 (f302 ?v1) (f16 (f17 f18 ?v2) ?v3))) f1)))) +(assert (forall ((?v0 S8) (?v1 S8) (?v2 S30)) (let ((?v_0 (f238 f185 ?v2))) (=> (= ?v0 ?v1) (= (= (f24 ?v_0 ?v0) f1) (= (f24 ?v_0 ?v1) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S29)) (let ((?v_0 (f237 f187 ?v2))) (=> (= ?v0 ?v1) (= (= (f20 ?v_0 ?v0) f1) (= (f20 ?v_0 ?v1) f1)))))) +(assert (forall ((?v0 S3) (?v1 S3) (?v2 S27)) (let ((?v_0 (f236 f189 ?v2))) (=> (= ?v0 ?v1) (= (= (f19 ?v_0 ?v0) f1) (= (f19 ?v_0 ?v1) f1)))))) +(assert (forall ((?v0 S24) (?v1 S8) (?v2 S8)) (=> (= (f11 (f234 ?v0) (f12 (f13 f14 ?v1) ?v2)) f1) (= (f24 (f28 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S25) (?v1 S3) (?v2 S3)) (=> (= (f15 (f235 ?v0) (f16 (f17 f18 ?v1) ?v2)) f1) (= (f19 (f31 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (=> (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1) (= (f34 (f35 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (=> (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (=> (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S27) (?v1 Int) (?v2 Int)) (= (= (f19 (f236 f189 ?v0) (f8 (f9 f10 ?v1) ?v2)) f1) (= (f34 (f35 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (= (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (= (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S29) (?v1 S18) (?v2 S18)) (= (= (f20 (f237 f187 ?v0) (f21 (f22 f23 ?v1) ?v2)) f1) (= (f38 (f39 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S17) (?v2 S17)) (= (= (f24 (f238 f185 ?v0) (f25 (f26 f27 ?v1) ?v2)) f1) (= (f20 (f42 ?v0 ?v1) ?v2) f1)))) +(assert (forall ((?v0 S30) (?v1 S8)) (=> (= (f24 (f238 f185 ?v0) ?v1) f1) (=> (forall ((?v2 S17) (?v3 S17)) (=> (= ?v1 (f25 (f26 f27 ?v2) ?v3)) (=> (= (f20 (f42 ?v0 ?v2) ?v3) f1) false))) false)))) +(assert (forall ((?v0 S29) (?v1 S17)) (=> (= (f20 (f237 f187 ?v0) ?v1) f1) (=> (forall ((?v2 S18) (?v3 S18)) (=> (= ?v1 (f21 (f22 f23 ?v2) ?v3)) (=> (= (f38 (f39 ?v0 ?v2) ?v3) f1) false))) false)))) +(assert (forall ((?v0 S27) (?v1 S3)) (=> (= (f19 (f236 f189 ?v0) ?v1) f1) (=> (forall ((?v2 Int) (?v3 Int)) (=> (= ?v1 (f8 (f9 f10 ?v2) ?v3)) (=> (= (f34 (f35 ?v0 ?v2) ?v3) f1) false))) false)))) +(assert (forall ((?v0 S8) (?v1 S30)) (=> (forall ((?v2 S17) (?v3 S17)) (=> (= ?v0 (f25 (f26 f27 ?v2) ?v3)) (= (f20 (f42 ?v1 ?v2) ?v3) f1))) (= (f24 (f238 f185 ?v1) ?v0) f1)))) +(assert (forall ((?v0 S17) (?v1 S29)) (=> (forall ((?v2 S18) (?v3 S18)) (=> (= ?v0 (f21 (f22 f23 ?v2) ?v3)) (= (f38 (f39 ?v1 ?v2) ?v3) f1))) (= (f20 (f237 f187 ?v1) ?v0) f1)))) +(assert (forall ((?v0 S3) (?v1 S27)) (=> (forall ((?v2 Int) (?v3 Int)) (=> (= ?v0 (f8 (f9 f10 ?v2) ?v3)) (= (f34 (f35 ?v1 ?v2) ?v3) f1))) (= (f19 (f236 f189 ?v1) ?v0) f1)))) +(assert (forall ((?v0 S18) (?v1 S18)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) f303) f1) (< (f154 f155 ?v0) (f154 f155 ?v1))))) +(assert (= f304 (f103 (f104 f303) f303))) +(assert (= (f305 f303) f1)) +(assert (forall ((?v0 S103)) (= (f306 (f163 ?v0)) f1))) +(assert (forall ((?v0 S102)) (= (f307 (f161 ?v0)) f1))) +(assert (forall ((?v0 S21)) (= (= (f308 ?v0) f1) (forall ((?v1 S17) (?v2 S17)) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2))))))) +(assert (forall ((?v0 S16)) (= (= (f309 ?v0) f1) (forall ((?v1 S18) (?v2 S18)) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2))))))) +(assert (forall ((?v0 S15)) (= (= (f310 ?v0) f1) (forall ((?v1 Int) (?v2 Int)) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2))))))) +(assert (= (f307 f303) f1)) +(assert (forall ((?v0 S16) (?v1 S16)) (=> (= (f307 ?v0) f1) (=> (= (f307 ?v1) f1) (= (f306 (f103 (f104 ?v0) ?v1)) f1))))) +(assert (forall ((?v0 S16) (?v1 S16)) (=> (= (f305 ?v0) f1) (=> (= (f305 ?v1) f1) (= (f311 (f103 (f104 ?v0) ?v1)) f1))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (<= (f154 f155 ?v0) (f154 f155 ?v1)) (=> (< (f154 f155 ?v2) (f154 f155 ?v3)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f304) f1))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (< (f154 f155 ?v0) (f154 f155 ?v1)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f304) f1)))) +(assert (= (f306 f304) f1)) +(assert (forall ((?v0 S21) (?v1 S17)) (=> (= (f306 ?v0) f1) (=> (=> (not (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1)) false) false)))) +(assert (forall ((?v0 S16) (?v1 S18)) (=> (= (f307 ?v0) f1) (=> (=> (not (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1)) false) false)))) +(assert (forall ((?v0 S15) (?v1 Int)) (=> (= (f312 ?v0) f1) (=> (=> (not (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1)) false) false)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (=> (not (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1)) false) false))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (=> (not (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1)) false) false))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (=> (not (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1)) false) false))))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (not (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (not (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (not (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1)))))) +(assert (forall ((?v0 S21) (?v1 S17)) (=> (= (f306 ?v0) f1) (not (= (f44 (f25 (f26 f27 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S16) (?v1 S18)) (=> (= (f307 ?v0) f1) (not (= (f41 (f21 (f22 f23 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S15) (?v1 Int)) (=> (= (f312 ?v0) f1) (not (= (f37 (f8 (f9 f10 ?v1) ?v1) ?v0) f1))))) +(assert (forall ((?v0 S8) (?v1 S21)) (= (= (f44 ?v0 ?v1) f1) (= (f24 ?v1 ?v0) f1)))) +(assert (forall ((?v0 S17) (?v1 S16)) (= (= (f41 ?v0 ?v1) f1) (= (f20 ?v1 ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17) (?v3 S17)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f311 ?v0) f1) (=> (= (f44 (f25 ?v_0 ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v0) f1) (= (f44 (f25 ?v_0 ?v3) ?v0) f1))))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18) (?v3 S18)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f305 ?v0) f1) (=> (= (f41 (f21 ?v_0 ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v0) f1) (= (f41 (f21 ?v_0 ?v3) ?v0) f1))))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int) (?v3 Int)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f313 ?v0) f1) (=> (= (f37 (f8 ?v_0 ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v0) f1) (= (f37 (f8 ?v_0 ?v3) ?v0) f1))))))) +(assert (forall ((?v0 S21)) (= (= (f311 ?v0) f1) (forall ((?v1 S17) (?v2 S17) (?v3 S17)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f44 (f25 ?v_0 ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v0) f1) (= (f44 (f25 ?v_0 ?v3) ?v0) f1)))))))) +(assert (forall ((?v0 S16)) (= (= (f305 ?v0) f1) (forall ((?v1 S18) (?v2 S18) (?v3 S18)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f41 (f21 ?v_0 ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v0) f1) (= (f41 (f21 ?v_0 ?v3) ?v0) f1)))))))) +(assert (forall ((?v0 S15)) (= (= (f313 ?v0) f1) (forall ((?v1 Int) (?v2 Int) (?v3 Int)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f37 (f8 ?v_0 ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v0) f1) (= (f37 (f8 ?v_0 ?v3) ?v0) f1)))))))) +(assert (forall ((?v0 S21) (?v1 S103)) (=> (= (f306 ?v0) f1) (= (f306 (f173 (f174 ?v1) ?v0)) f1)))) +(assert (forall ((?v0 S16) (?v1 S102)) (=> (= (f307 ?v0) f1) (= (f307 (f171 (f172 ?v1) ?v0)) f1)))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (= (f308 ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (= (f309 ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (= (f310 ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))))) +(assert (forall ((?v0 S28) (?v1 S43)) (=> (forall ((?v2 S18)) (=> (= (f38 ?v0 ?v2) f1) (= (f307 (f61 ?v1 ?v2)) f1))) (= (f306 (f62 (f63 ?v0) ?v1)) f1)))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S17) (?v2 S17)) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))) (= (f308 ?v0) f1)))) +(assert (forall ((?v0 S16)) (=> (forall ((?v1 S18) (?v2 S18)) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))) (= (f309 ?v0) f1)))) +(assert (forall ((?v0 S15)) (=> (forall ((?v1 Int) (?v2 Int)) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v1) ?v0) f1) (= ?v1 ?v2)))) (= (f310 ?v0) f1)))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S17) (?v2 S17) (?v3 S17)) (let ((?v_0 (f26 f27 ?v1))) (=> (= (f44 (f25 ?v_0 ?v2) ?v0) f1) (=> (= (f44 (f25 (f26 f27 ?v2) ?v3) ?v0) f1) (= (f44 (f25 ?v_0 ?v3) ?v0) f1))))) (= (f311 ?v0) f1)))) +(assert (forall ((?v0 S16)) (=> (forall ((?v1 S18) (?v2 S18) (?v3 S18)) (let ((?v_0 (f22 f23 ?v1))) (=> (= (f41 (f21 ?v_0 ?v2) ?v0) f1) (=> (= (f41 (f21 (f22 f23 ?v2) ?v3) ?v0) f1) (= (f41 (f21 ?v_0 ?v3) ?v0) f1))))) (= (f305 ?v0) f1)))) +(assert (forall ((?v0 S15)) (=> (forall ((?v1 Int) (?v2 Int) (?v3 Int)) (let ((?v_0 (f9 f10 ?v1))) (=> (= (f37 (f8 ?v_0 ?v2) ?v0) f1) (=> (= (f37 (f8 (f9 f10 ?v2) ?v3) ?v0) f1) (= (f37 (f8 ?v_0 ?v3) ?v0) f1))))) (= (f313 ?v0) f1)))) +(assert (forall ((?v0 S21)) (= (= (f306 ?v0) f1) (forall ((?v1 S16) (?v2 S17)) (=> (= (f41 ?v2 ?v1) f1) (exists ((?v3 S17)) (and (= (f41 ?v3 ?v1) f1) (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (not (= (f41 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S16)) (= (= (f307 ?v0) f1) (forall ((?v1 S28) (?v2 S18)) (=> (= (f182 ?v2 ?v1) f1) (exists ((?v3 S18)) (and (= (f182 ?v3 ?v1) f1) (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (not (= (f182 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S6)) (= (= (f314 ?v0) f1) (forall ((?v1 S21) (?v2 S8)) (=> (= (f44 ?v2 ?v1) f1) (exists ((?v3 S8)) (and (= (f44 ?v3 ?v1) f1) (forall ((?v4 S8)) (=> (= (f30 (f12 (f13 f14 ?v4) ?v3) ?v0) f1) (not (= (f44 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S15)) (= (= (f312 ?v0) f1) (forall ((?v1 S26) (?v2 Int)) (=> (= (f179 ?v2 ?v1) f1) (exists ((?v3 Int)) (and (= (f179 ?v3 ?v1) f1) (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (not (= (f179 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S21) (?v1 S103) (?v2 S103)) (=> (forall ((?v3 S17) (?v4 S17)) (let ((?v_0 (f154 f155 (f164 ?v1 ?v3))) (?v_1 (f154 f155 (f164 ?v2 ?v4)))) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (and (<= (f154 f155 (f164 ?v1 ?v4)) ?v_0) (and (<= ?v_1 ?v_0) (< (f154 f155 (f164 ?v2 ?v3)) ?v_1)))))) (= (f306 ?v0) f1)))) +(assert (forall ((?v0 S16) (?v1 S102) (?v2 S102)) (=> (forall ((?v3 S18) (?v4 S18)) (let ((?v_0 (f154 f155 (f162 ?v1 ?v3))) (?v_1 (f154 f155 (f162 ?v2 ?v4)))) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (and (<= (f154 f155 (f162 ?v1 ?v4)) ?v_0) (and (<= ?v_1 ?v_0) (< (f154 f155 (f162 ?v2 ?v3)) ?v_1)))))) (= (f307 ?v0) f1)))) +(assert (forall ((?v0 S15) (?v1 S101) (?v2 S101)) (=> (forall ((?v3 Int) (?v4 Int)) (let ((?v_0 (f154 f155 (f160 ?v1 ?v3))) (?v_1 (f154 f155 (f160 ?v2 ?v4)))) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (and (<= (f154 f155 (f160 ?v1 ?v4)) ?v_0) (and (<= ?v_1 ?v_0) (< (f154 f155 (f160 ?v2 ?v3)) ?v_1)))))) (= (f312 ?v0) f1)))) +(assert (forall ((?v0 S21)) (= (= (f306 ?v0) f1) (not (exists ((?v1 S19)) (forall ((?v2 S18)) (= (f44 (f25 (f26 f27 (f21 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f21 ?v1 ?v2)) ?v0) f1))))))) +(assert (forall ((?v0 S16)) (= (= (f307 ?v0) f1) (not (exists ((?v1 S102)) (forall ((?v2 S18)) (= (f41 (f21 (f22 f23 (f162 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f162 ?v1 ?v2)) ?v0) f1))))))) +(assert (forall ((?v0 S15)) (= (= (f312 ?v0) f1) (not (exists ((?v1 S99)) (forall ((?v2 S18)) (= (f37 (f8 (f9 f10 (f154 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f154 ?v1 ?v2)) ?v0) f1))))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f316 (f43 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f317 (f40 ?v0)) f1)))) +(assert (forall ((?v0 S21) (?v1 S19)) (=> (= (f306 ?v0) f1) (=> (forall ((?v2 S18)) (=> (not (= (f44 (f25 (f26 f27 (f21 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f21 ?v1 ?v2)) ?v0) f1)) false)) false)))) +(assert (forall ((?v0 S16) (?v1 S102)) (=> (= (f307 ?v0) f1) (=> (forall ((?v2 S18)) (=> (not (= (f41 (f21 (f22 f23 (f162 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f162 ?v1 ?v2)) ?v0) f1)) false)) false)))) +(assert (forall ((?v0 S15) (?v1 S99)) (=> (= (f312 ?v0) f1) (=> (forall ((?v2 S18)) (=> (not (= (f37 (f8 (f9 f10 (f154 ?v1 (f160 f315 (+ (f154 f155 ?v2) 1)))) (f154 ?v1 ?v2)) ?v0) f1)) false)) false)))) +(assert (forall ((?v0 S24)) (= (= (f318 ?v0) f1) (forall ((?v1 S21) (?v2 S8)) (=> (= (f44 ?v2 ?v1) f1) (exists ((?v3 S8)) (and (= (f44 ?v3 ?v1) f1) (forall ((?v4 S8)) (=> (= (f24 (f28 ?v0 ?v4) ?v3) f1) (not (= (f44 ?v4 ?v1) f1))))))))))) +(assert (forall ((?v0 S30)) (= (= (f316 ?v0) f1) (forall ((?v1 S16) (?v2 S17)) (=> (= (f41 ?v2 ?v1) f1) (exists ((?v3 S17)) (and (= (f41 ?v3 ?v1) f1) (forall ((?v4 S17)) (=> (= (f20 (f42 ?v0 ?v4) ?v3) f1) (not (= (f41 ?v4 ?v1) f1))))))))))) +(assert (= (f307 f319) f1)) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (< (f154 f155 ?v0) (f154 f155 ?v1)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f320) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18)) (=> (<= (f154 f155 ?v0) (f154 f155 ?v1)) (=> (<= (f154 f155 ?v2) (f154 f155 ?v3)) (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v2)) (f21 (f22 f23 ?v1) ?v3)) f320) f1))))) +(assert (forall ((?v0 S21)) (= (= (f306 ?v0) f1) (forall ((?v1 S16)) (=> (forall ((?v2 S17)) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v3) ?v2) ?v0) f1) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))) (forall ((?v2 S17)) (= (f20 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S16)) (= (= (f307 ?v0) f1) (forall ((?v1 S28)) (=> (forall ((?v2 S18)) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v3) ?v2) ?v0) f1) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))) (forall ((?v2 S18)) (= (f38 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S15)) (= (= (f312 ?v0) f1) (forall ((?v1 S26)) (=> (forall ((?v2 Int)) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v3) ?v2) ?v0) f1) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))) (forall ((?v2 Int)) (= (f34 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S21)) (=> (forall ((?v1 S17) (?v2 S16)) (=> (= (f41 ?v1 ?v2) f1) (exists ((?v3 S17)) (and (= (f41 ?v3 ?v2) f1) (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (not (= (f41 ?v4 ?v2) f1)))))))) (= (f306 ?v0) f1)))) +(assert (forall ((?v0 S16)) (=> (forall ((?v1 S18) (?v2 S28)) (=> (= (f182 ?v1 ?v2) f1) (exists ((?v3 S18)) (and (= (f182 ?v3 ?v2) f1) (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (not (= (f182 ?v4 ?v2) f1)))))))) (= (f307 ?v0) f1)))) +(assert (forall ((?v0 S6)) (=> (forall ((?v1 S8) (?v2 S21)) (=> (= (f44 ?v1 ?v2) f1) (exists ((?v3 S8)) (and (= (f44 ?v3 ?v2) f1) (forall ((?v4 S8)) (=> (= (f30 (f12 (f13 f14 ?v4) ?v3) ?v0) f1) (not (= (f44 ?v4 ?v2) f1)))))))) (= (f314 ?v0) f1)))) +(assert (forall ((?v0 S15)) (=> (forall ((?v1 Int) (?v2 S26)) (=> (= (f179 ?v1 ?v2) f1) (exists ((?v3 Int)) (and (= (f179 ?v3 ?v2) f1) (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (not (= (f179 ?v4 ?v2) f1)))))))) (= (f312 ?v0) f1)))) +(assert (forall ((?v0 S21) (?v1 S16) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (forall ((?v3 S17)) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (= (f20 ?v1 ?v4) f1))) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S16) (?v1 S28) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (forall ((?v3 S18)) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (= (f38 ?v1 ?v4) f1))) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S15) (?v1 S26) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (forall ((?v3 Int)) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (= (f34 ?v1 ?v4) f1))) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S21) (?v1 S16) (?v2 S17)) (=> (= (f306 ?v0) f1) (=> (forall ((?v3 S17)) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (= (f20 ?v1 ?v4) f1))) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S16) (?v1 S28) (?v2 S18)) (=> (= (f307 ?v0) f1) (=> (forall ((?v3 S18)) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (= (f38 ?v1 ?v4) f1))) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S15) (?v1 S26) (?v2 Int)) (=> (= (f312 ?v0) f1) (=> (forall ((?v3 Int)) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (= (f34 ?v1 ?v4) f1))) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S16)) (=> (= (f306 ?v0) f1) (=> (= (f41 ?v1 ?v2) f1) (=> (forall ((?v3 S17)) (=> (= (f41 ?v3 ?v2) f1) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v3) ?v0) f1) (not (= (f41 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S28)) (=> (= (f307 ?v0) f1) (=> (= (f182 ?v1 ?v2) f1) (=> (forall ((?v3 S18)) (=> (= (f182 ?v3 ?v2) f1) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v3) ?v0) f1) (not (= (f182 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S6) (?v1 S8) (?v2 S21)) (=> (= (f314 ?v0) f1) (=> (= (f44 ?v1 ?v2) f1) (=> (forall ((?v3 S8)) (=> (= (f44 ?v3 ?v2) f1) (=> (forall ((?v4 S8)) (=> (= (f30 (f12 (f13 f14 ?v4) ?v3) ?v0) f1) (not (= (f44 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 S26)) (=> (= (f312 ?v0) f1) (=> (= (f179 ?v1 ?v2) f1) (=> (forall ((?v3 Int)) (=> (= (f179 ?v3 ?v2) f1) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v3) ?v0) f1) (not (= (f179 ?v4 ?v2) f1)))) false))) false))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (forall ((?v1 S16)) (=> (forall ((?v2 S17)) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v3) ?v2) ?v0) f1) (= (f20 ?v1 ?v3) f1))) (= (f20 ?v1 ?v2) f1))) (forall ((?v2 S17)) (= (f20 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (forall ((?v1 S28)) (=> (forall ((?v2 S18)) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v3) ?v2) ?v0) f1) (= (f38 ?v1 ?v3) f1))) (= (f38 ?v1 ?v2) f1))) (forall ((?v2 S18)) (= (f38 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S15)) (=> (= (f312 ?v0) f1) (forall ((?v1 S26)) (=> (forall ((?v2 Int)) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v3) ?v2) ?v0) f1) (= (f34 ?v1 ?v3) f1))) (= (f34 ?v1 ?v2) f1))) (forall ((?v2 Int)) (= (f34 ?v1 ?v2) f1))))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f321 (f322 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f323 (f324 ?v0)) f1)))) +(assert (= f303 (f325 f319))) +(assert (forall ((?v0 S18) (?v1 S18)) (= (= (f41 (f21 (f22 f23 ?v0) ?v1) (f325 f319)) f1) (< (f154 f155 ?v0) (f154 f155 ?v1))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f306 (f326 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f307 (f325 ?v0)) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21)) (let ((?v_0 (f25 (f26 f27 ?v0) ?v1))) (=> (= (f44 ?v_0 ?v2) f1) (= (f44 ?v_0 (f326 ?v2)) f1))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16)) (let ((?v_0 (f21 (f22 f23 ?v0) ?v1))) (=> (= (f41 ?v_0 ?v2) f1) (= (f41 ?v_0 (f325 ?v2)) f1))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15)) (let ((?v_0 (f8 (f9 f10 ?v0) ?v1))) (=> (= (f37 ?v_0 ?v2) f1) (= (f37 ?v_0 (f327 ?v2)) f1))))) +(assert (forall ((?v0 S16)) (=> (= (f305 ?v0) f1) (= (f325 ?v0) ?v0)))) +(assert (forall ((?v0 S16)) (= (f305 (f325 ?v0)) f1))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_0 (f26 f27 ?v0))) (=> (= (f44 (f25 ?v_0 ?v1) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v2) f1) (= (f44 (f25 ?v_0 ?v3) (f326 ?v2)) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_0 (f22 f23 ?v0))) (=> (= (f41 (f21 ?v_0 ?v1) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v2) f1) (= (f41 (f21 ?v_0 ?v3) (f325 ?v2)) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_0 (f9 f10 ?v0))) (=> (= (f37 (f8 ?v_0 ?v1) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v2) f1) (= (f37 (f8 ?v_0 ?v3) (f327 ?v2)) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_0 (f26 f27 ?v0)) (?v_1 (f326 ?v2))) (=> (= (f44 (f25 ?v_0 ?v1) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v_1) f1) (= (f44 (f25 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_0 (f22 f23 ?v0)) (?v_1 (f325 ?v2))) (=> (= (f41 (f21 ?v_0 ?v1) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v_1) f1) (= (f41 (f21 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_0 (f9 f10 ?v0)) (?v_1 (f327 ?v2))) (=> (= (f37 (f8 ?v_0 ?v1) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v_1) f1) (= (f37 (f8 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S8) (?v1 S21)) (=> (= (f44 ?v0 ?v1) f1) (= (f44 ?v0 (f326 ?v1)) f1)))) +(assert (forall ((?v0 S17) (?v1 S16)) (=> (= (f41 ?v0 ?v1) f1) (= (f41 ?v0 (f325 ?v1)) f1)))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_1 (f26 f27 ?v0)) (?v_0 (f326 ?v2))) (=> (= (f44 (f25 ?v_1 ?v1) ?v_0) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v_0) f1) (= (f44 (f25 ?v_1 ?v3) ?v_0) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_1 (f22 f23 ?v0)) (?v_0 (f325 ?v2))) (=> (= (f41 (f21 ?v_1 ?v1) ?v_0) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v_0) f1) (= (f41 (f21 ?v_1 ?v3) ?v_0) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_1 (f9 f10 ?v0)) (?v_0 (f327 ?v2))) (=> (= (f37 (f8 ?v_1 ?v1) ?v_0) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v_0) f1) (= (f37 (f8 ?v_1 ?v3) ?v_0) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S17)) (let ((?v_0 (f26 f27 ?v0)) (?v_1 (f326 ?v2))) (=> (= (f44 (f25 ?v_0 ?v1) ?v_1) f1) (=> (= (f44 (f25 (f26 f27 ?v1) ?v3) ?v2) f1) (= (f44 (f25 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S18)) (let ((?v_0 (f22 f23 ?v0)) (?v_1 (f325 ?v2))) (=> (= (f41 (f21 ?v_0 ?v1) ?v_1) f1) (=> (= (f41 (f21 (f22 f23 ?v1) ?v3) ?v2) f1) (= (f41 (f21 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 Int)) (let ((?v_0 (f9 f10 ?v0)) (?v_1 (f327 ?v2))) (=> (= (f37 (f8 ?v_0 ?v1) ?v_1) f1) (=> (= (f37 (f8 (f9 f10 ?v1) ?v3) ?v2) f1) (= (f37 (f8 ?v_0 ?v3) ?v_1) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21)) (let ((?v_0 (f25 (f26 f27 ?v0) ?v1))) (=> (= (f44 ?v_0 (f326 ?v2)) f1) (=> (=> (= (f44 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v3) (f326 ?v2)) f1) (=> (= (f44 (f25 (f26 f27 ?v3) ?v1) ?v2) f1) false))) false)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16)) (let ((?v_0 (f21 (f22 f23 ?v0) ?v1))) (=> (= (f41 ?v_0 (f325 ?v2)) f1) (=> (=> (= (f41 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v3) (f325 ?v2)) f1) (=> (= (f41 (f21 (f22 f23 ?v3) ?v1) ?v2) f1) false))) false)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15)) (let ((?v_0 (f8 (f9 f10 ?v0) ?v1))) (=> (= (f37 ?v_0 (f327 ?v2)) f1) (=> (=> (= (f37 ?v_0 ?v2) f1) false) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v3) (f327 ?v2)) f1) (=> (= (f37 (f8 (f9 f10 ?v3) ?v1) ?v2) f1) false))) false)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21)) (let ((?v_0 (f25 (f26 f27 ?v0) ?v1))) (=> (= (f44 ?v_0 (f326 ?v2)) f1) (=> (=> (= (f44 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v3) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v3) ?v1) (f326 ?v2)) f1) false))) false)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16)) (let ((?v_0 (f21 (f22 f23 ?v0) ?v1))) (=> (= (f41 ?v_0 (f325 ?v2)) f1) (=> (=> (= (f41 ?v_0 ?v2) f1) false) (=> (forall ((?v3 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v3) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v3) ?v1) (f325 ?v2)) f1) false))) false)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15)) (let ((?v_0 (f8 (f9 f10 ?v0) ?v1))) (=> (= (f37 ?v_0 (f327 ?v2)) f1) (=> (=> (= (f37 ?v_0 ?v2) f1) false) (=> (forall ((?v3 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v3) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v3) ?v1) (f327 ?v2)) f1) false))) false)))))) +(assert (forall ((?v0 S21) (?v1 S17) (?v2 S17)) (=> (forall ((?v3 S17)) (not (= (f44 (f25 (f26 f27 ?v3) ?v3) (f326 ?v0)) f1))) (=> (= (f44 (f25 (f26 f27 ?v1) ?v2) ?v0) f1) (not (= ?v1 ?v2)))))) +(assert (forall ((?v0 S16) (?v1 S18) (?v2 S18)) (=> (forall ((?v3 S18)) (not (= (f41 (f21 (f22 f23 ?v3) ?v3) (f325 ?v0)) f1))) (=> (= (f41 (f21 (f22 f23 ?v1) ?v2) ?v0) f1) (not (= ?v1 ?v2)))))) +(assert (forall ((?v0 S15) (?v1 Int) (?v2 Int)) (=> (forall ((?v3 Int)) (not (= (f37 (f8 (f9 f10 ?v3) ?v3) (f327 ?v0)) f1))) (=> (= (f37 (f8 (f9 f10 ?v1) ?v2) ?v0) f1) (not (= ?v1 ?v2)))))) +(assert (forall ((?v0 S21)) (=> (= (f306 ?v0) f1) (= (f321 (f328 ?v0)) f1)))) +(assert (forall ((?v0 S16)) (=> (= (f307 ?v0) f1) (= (f323 (f329 ?v0)) f1)))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S18) (?v3 S18) (?v4 S21) (?v5 S29)) (=> (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v1)) (f21 (f22 f23 ?v2) ?v3)) (f326 ?v4)) f1) (=> (forall ((?v6 S18) (?v7 S18)) (=> (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v1)) (f21 (f22 f23 ?v6) ?v7)) ?v4) f1) (= (f38 (f39 ?v5 ?v6) ?v7) f1))) (=> (forall ((?v6 S18) (?v7 S18) (?v8 S18) (?v9 S18)) (let ((?v_0 (f21 (f22 f23 ?v6) ?v7))) (=> (= (f44 (f25 (f26 f27 (f21 (f22 f23 ?v0) ?v1)) ?v_0) (f326 ?v4)) f1) (=> (= (f44 (f25 (f26 f27 ?v_0) (f21 (f22 f23 ?v8) ?v9)) ?v4) f1) (=> (= (f38 (f39 ?v5 ?v6) ?v7) f1) (= (f38 (f39 ?v5 ?v8) ?v9) f1)))))) (= (f38 (f39 ?v5 ?v2) ?v3) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S17) (?v3 S17) (?v4 S6) (?v5 S30)) (=> (= (f30 (f12 (f13 f14 (f25 (f26 f27 ?v0) ?v1)) (f25 (f26 f27 ?v2) ?v3)) (f330 ?v4)) f1) (=> (forall ((?v6 S17) (?v7 S17)) (=> (= (f30 (f12 (f13 f14 (f25 (f26 f27 ?v0) ?v1)) (f25 (f26 f27 ?v6) ?v7)) ?v4) f1) (= (f20 (f42 ?v5 ?v6) ?v7) f1))) (=> (forall ((?v6 S17) (?v7 S17) (?v8 S17) (?v9 S17)) (let ((?v_0 (f25 (f26 f27 ?v6) ?v7))) (=> (= (f30 (f12 (f13 f14 (f25 (f26 f27 ?v0) ?v1)) ?v_0) (f330 ?v4)) f1) (=> (= (f30 (f12 (f13 f14 ?v_0) (f25 (f26 f27 ?v8) ?v9)) ?v4) f1) (=> (= (f20 (f42 ?v5 ?v6) ?v7) f1) (= (f20 (f42 ?v5 ?v8) ?v9) f1)))))) (= (f20 (f42 ?v5 ?v2) ?v3) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 Int) (?v3 Int) (?v4 S11) (?v5 S27)) (=> (= (f33 (f16 (f17 f18 (f8 (f9 f10 ?v0) ?v1)) (f8 (f9 f10 ?v2) ?v3)) (f331 ?v4)) f1) (=> (forall ((?v6 Int) (?v7 Int)) (=> (= (f33 (f16 (f17 f18 (f8 (f9 f10 ?v0) ?v1)) (f8 (f9 f10 ?v6) ?v7)) ?v4) f1) (= (f34 (f35 ?v5 ?v6) ?v7) f1))) (=> (forall ((?v6 Int) (?v7 Int) (?v8 Int) (?v9 Int)) (let ((?v_0 (f8 (f9 f10 ?v6) ?v7))) (=> (= (f33 (f16 (f17 f18 (f8 (f9 f10 ?v0) ?v1)) ?v_0) (f331 ?v4)) f1) (=> (= (f33 (f16 (f17 f18 ?v_0) (f8 (f9 f10 ?v8) ?v9)) ?v4) f1) (=> (= (f34 (f35 ?v5 ?v6) ?v7) f1) (= (f34 (f35 ?v5 ?v8) ?v9) f1)))))) (= (f34 (f35 ?v5 ?v2) ?v3) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S16)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v1) (f326 ?v2)) f1) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v1) ?v2) f1) (= (f20 ?v3 ?v4) f1))) (=> (forall ((?v4 S17) (?v5 S17)) (=> (= (f44 (f25 (f26 f27 ?v4) ?v5) ?v2) f1) (=> (= (f44 (f25 (f26 f27 ?v5) ?v1) (f326 ?v2)) f1) (=> (= (f20 ?v3 ?v5) f1) (= (f20 ?v3 ?v4) f1))))) (= (f20 ?v3 ?v0) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S28)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v1) (f325 ?v2)) f1) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v1) ?v2) f1) (= (f38 ?v3 ?v4) f1))) (=> (forall ((?v4 S18) (?v5 S18)) (=> (= (f41 (f21 (f22 f23 ?v4) ?v5) ?v2) f1) (=> (= (f41 (f21 (f22 f23 ?v5) ?v1) (f325 ?v2)) f1) (=> (= (f38 ?v3 ?v5) f1) (= (f38 ?v3 ?v4) f1))))) (= (f38 ?v3 ?v0) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 S26)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v1) (f327 ?v2)) f1) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v1) ?v2) f1) (= (f34 ?v3 ?v4) f1))) (=> (forall ((?v4 Int) (?v5 Int)) (=> (= (f37 (f8 (f9 f10 ?v4) ?v5) ?v2) f1) (=> (= (f37 (f8 (f9 f10 ?v5) ?v1) (f327 ?v2)) f1) (=> (= (f34 ?v3 ?v5) f1) (= (f34 ?v3 ?v4) f1))))) (= (f34 ?v3 ?v0) f1)))))) +(assert (forall ((?v0 S17) (?v1 S17) (?v2 S21) (?v3 S16)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v1) (f326 ?v2)) f1) (=> (forall ((?v4 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v4) ?v2) f1) (= (f20 ?v3 ?v4) f1))) (=> (forall ((?v4 S17) (?v5 S17)) (=> (= (f44 (f25 (f26 f27 ?v0) ?v4) (f326 ?v2)) f1) (=> (= (f44 (f25 (f26 f27 ?v4) ?v5) ?v2) f1) (=> (= (f20 ?v3 ?v4) f1) (= (f20 ?v3 ?v5) f1))))) (= (f20 ?v3 ?v1) f1)))))) +(assert (forall ((?v0 S18) (?v1 S18) (?v2 S16) (?v3 S28)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v1) (f325 ?v2)) f1) (=> (forall ((?v4 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v4) ?v2) f1) (= (f38 ?v3 ?v4) f1))) (=> (forall ((?v4 S18) (?v5 S18)) (=> (= (f41 (f21 (f22 f23 ?v0) ?v4) (f325 ?v2)) f1) (=> (= (f41 (f21 (f22 f23 ?v4) ?v5) ?v2) f1) (=> (= (f38 ?v3 ?v4) f1) (= (f38 ?v3 ?v5) f1))))) (= (f38 ?v3 ?v1) f1)))))) +(assert (forall ((?v0 Int) (?v1 Int) (?v2 S15) (?v3 S26)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v1) (f327 ?v2)) f1) (=> (forall ((?v4 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v4) ?v2) f1) (= (f34 ?v3 ?v4) f1))) (=> (forall ((?v4 Int) (?v5 Int)) (=> (= (f37 (f8 (f9 f10 ?v0) ?v4) (f327 ?v2)) f1) (=> (= (f37 (f8 (f9 f10 ?v4) ?v5) ?v2) f1) (=> (= (f34 ?v3 ?v4) f1) (= (f34 ?v3 ?v5) f1))))) (= (f34 ?v3 ?v1) f1)))))) +(assert (forall ((?v0 S18)) (= (f160 f315 (f154 f155 ?v0)) ?v0))) +(assert (forall ((?v0 Int)) (=> (<= 0 ?v0) (= (f154 f155 (f160 f315 ?v0)) ?v0)))) +(assert (forall ((?v0 Int)) (=> (< ?v0 0) (= (f154 f155 (f160 f315 ?v0)) 0)))) +(check-sat) +(exit) diff --git a/test/regress/regress0/nl/red-exp.smt2 b/test/regress/regress0/nl/red-exp.smt2 new file mode 100644 index 000000000..9a413902d --- /dev/null +++ b/test/regress/regress0/nl/red-exp.smt2 @@ -0,0 +1,11 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) + +(assert (or (= a (* b b)) (and (= a 9) (= b 3)))) +(assert (not (= (* a a) (* b b b b)))) +(check-sat) diff --git a/test/regress/regress0/nl/rewriting-sums.smt2 b/test/regress/regress0/nl/rewriting-sums.smt2 new file mode 100644 index 000000000..9d0f33e9f --- /dev/null +++ b/test/regress/regress0/nl/rewriting-sums.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NIA) +(set-info :status unsat) +(declare-fun x () Int) +(declare-fun y () Int) +(declare-fun z () Int) + + +(assert (or (= x 5) (= x 7) (= x 9))) + +(assert (or (= y (+ x 1)) (= y (+ x 2)))) + +(assert (or (= z (+ y 5)) (= z (+ y 10)))) + +(assert (> (* z z) 1000000000)) + +(check-sat) diff --git a/test/regress/regress0/nl/simple-mono-unsat.smt2 b/test/regress/regress0/nl/simple-mono-unsat.smt2 new file mode 100644 index 000000000..e640c943b --- /dev/null +++ b/test/regress/regress0/nl/simple-mono-unsat.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) + +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) + +(assert (or (= a 4) (= a 3))) + +(assert (> b 0)) +(assert (> c 0)) + +(assert (< (* a b c d d) 0)) + +(check-sat) diff --git a/test/regress/regress0/nl/simple-mono.smt2 b/test/regress/regress0/nl/simple-mono.smt2 new file mode 100644 index 000000000..a9761fa5a --- /dev/null +++ b/test/regress/regress0/nl/simple-mono.smt2 @@ -0,0 +1,17 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun x () Real) +(declare-fun y () Real) +(declare-fun z () Real) + + +(assert (> z 0)) +(assert (> x y)) + +;(assert (not (> (* x z) (* y z)))) +(assert (< (* x z) (* y z))) + + +(check-sat) diff --git a/test/regress/regress0/nl/subs0-unsat-confirm.smt2 b/test/regress/regress0/nl/subs0-unsat-confirm.smt2 new file mode 100644 index 000000000..044f7654c --- /dev/null +++ b/test/regress/regress0/nl/subs0-unsat-confirm.smt2 @@ -0,0 +1,18 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun v1 () Real) +(declare-fun v2 () Real) +(declare-fun v3 () Real) +(declare-fun v4 () Real) +(declare-fun v5 () Real) +(declare-fun v6 () Real) +(declare-fun v7 () Real) +(declare-fun v8 () Real) + +(assert (or (= v1 0) (= v2 0))) + +(assert (not (= (* v1 v2 v3 v4 v5 v6 v7) 0))) + +(check-sat) diff --git a/test/regress/regress0/nl/very-easy-sat.smt2 b/test/regress/regress0/nl/very-easy-sat.smt2 new file mode 100644 index 000000000..b9aecac7a --- /dev/null +++ b/test/regress/regress0/nl/very-easy-sat.smt2 @@ -0,0 +1,30 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: sat +(set-logic QF_NRA) +(set-info :source | +These benchmarks used in the paper: + + Dejan Jovanovic and Leonardo de Moura. Solving Non-Linear Arithmetic. + In IJCAR 2012, published as LNCS volume 7364, pp. 339--354. + +The meti-tarski benchmarks are proof obligations extracted from the +Meti-Tarski project, see: + + B. Akbarpour and L. C. Paulson. MetiTarski: An automatic theorem prover + for real-valued special functions. Journal of Automated Reasoning, + 44(3):175-205, 2010. + +Submitted by Dejan Jovanovic for SMT-LIB. + + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "industrial") +(set-info :status sat) +(declare-fun skoC () Real) +(declare-fun skoS () Real) +(declare-fun skoCB () Real) +(declare-fun skoSB () Real) +(declare-fun skoX () Real) +(assert (and (<= skoX (/ 177 366500000)) (and (not (<= (/ 177 366500000) skoX)) (and (= (* skoSB skoSB) (+ 1 (* skoCB (* skoCB (- 1))))) (and (= (* skoS skoS) (+ 1 (* skoC (* skoC (- 1))))) (and (<= skoX (/ 1 10000000)) (<= 0 skoX))))))) +(check-sat) diff --git a/test/regress/regress0/nl/very-simple-unsat.smt2 b/test/regress/regress0/nl/very-simple-unsat.smt2 new file mode 100644 index 000000000..bcfdaad40 --- /dev/null +++ b/test/regress/regress0/nl/very-simple-unsat.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :source | +Harald Roman Zankl + +|) +(set-info :smt-lib-version 2.0) +(set-info :category "crafted") +(set-info :status unsat) +(declare-fun a () Real) +(assert (= (* a a) (- 2))) +(check-sat) +(exit) + diff --git a/test/regress/regress0/nl/zero-subset.smt2 b/test/regress/regress0/nl/zero-subset.smt2 new file mode 100644 index 000000000..6087551c1 --- /dev/null +++ b/test/regress/regress0/nl/zero-subset.smt2 @@ -0,0 +1,15 @@ +; COMMAND-LINE: --nl-alg +; EXPECT: unsat +(set-logic QF_NRA) +(set-info :status unsat) +(declare-fun a () Real) +(declare-fun b () Real) +(declare-fun c () Real) +(declare-fun d () Real) +(declare-fun e () Real) + +(assert (= (* a b c d) 0)) + +(assert (not (= (* a b c d e) 0))) + +(check-sat) -- cgit v1.2.3