diff --git a/doc/mk_api_doc.py b/doc/mk_api_doc.py index 1b498fb19d3..e45f56134ae 100644 --- a/doc/mk_api_doc.py +++ b/doc/mk_api_doc.py @@ -1,3 +1,5 @@ +# Copyright (c) Microsoft Corporation 2015 + import os import shutil import re diff --git a/examples/c++/example.cpp b/examples/c++/example.cpp index c20800f2596..660db61d8a5 100644 --- a/examples/c++/example.cpp +++ b/examples/c++/example.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include"z3++.h" diff --git a/examples/c/test_capi.c b/examples/c/test_capi.c index c0ea7045353..cb63fe6238f 100644 --- a/examples/c/test_capi.c +++ b/examples/c/test_capi.c @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include #include diff --git a/examples/interp/iz3.cpp b/examples/interp/iz3.cpp index 6d631ebc927..9f55c1ec627 100755 --- a/examples/interp/iz3.cpp +++ b/examples/interp/iz3.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include #include diff --git a/examples/maxsat/maxsat.c b/examples/maxsat/maxsat.c index 5ca70781167..f04c25e2c5d 100644 --- a/examples/maxsat/maxsat.c +++ b/examples/maxsat/maxsat.c @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + /* Simple MAXSAT solver on top of the Z3 API. */ diff --git a/examples/msf/SolverFoundation.Plugin.Z3.Tests/ServiceTests.cs b/examples/msf/SolverFoundation.Plugin.Z3.Tests/ServiceTests.cs index 25a8e2d2693..196f892457c 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3.Tests/ServiceTests.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3.Tests/ServiceTests.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Linq; diff --git a/examples/msf/SolverFoundation.Plugin.Z3.Tests/SolverTests.cs b/examples/msf/SolverFoundation.Plugin.Z3.Tests/SolverTests.cs index c2cd0c270e5..4913c0f81e7 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3.Tests/SolverTests.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3.Tests/SolverTests.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Linq; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/AbortWorker.cs b/examples/msf/SolverFoundation.Plugin.Z3/AbortWorker.cs index 99d6fe17ade..6ce66fa8fbc 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/AbortWorker.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/AbortWorker.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Linq; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Utils.cs b/examples/msf/SolverFoundation.Plugin.Z3/Utils.cs index 71c8647a180..5930caee143 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Utils.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Utils.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Linq; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseDirective.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseDirective.cs index e1403f6980e..199c3fe3531 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseDirective.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseDirective.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Text; using Microsoft.SolverFoundation.Services; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseParams.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseParams.cs index 6585181ec4c..6d6dd74a7c9 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseParams.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseParams.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using Microsoft.SolverFoundation.Services; using System; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs index 54e3893f05d..af8bc92a284 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Threading; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPDirective.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPDirective.cs index 69f9ff6c107..4d674563454 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPDirective.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPDirective.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using Microsoft.SolverFoundation.Services; using System; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPParams.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPParams.cs index 38bd9040a81..d01b077251b 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPParams.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPParams.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using Microsoft.SolverFoundation.Services; using System; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs index b31f6de97bb..f3a8f9f2c11 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Diagnostics; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermDirective.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermDirective.cs index 12dcb6e841a..ff9e4181a6c 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermDirective.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermDirective.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using Microsoft.SolverFoundation.Services; using System; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermParams.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermParams.cs index 48a90afe168..283bc9362d7 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermParams.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermParams.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using Microsoft.SolverFoundation.Services; using System; diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs index 3317b9a4d1b..530df339497 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Threading; using System.Globalization; diff --git a/examples/msf/Validator/Program.cs b/examples/msf/Validator/Program.cs index 758c65c7869..8afb28af555 100644 --- a/examples/msf/Validator/Program.cs +++ b/examples/msf/Validator/Program.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.IO; using System.Linq; diff --git a/examples/python/example.py b/examples/python/example.py index 879c17c4376..e0c9374e7f7 100644 --- a/examples/python/example.py +++ b/examples/python/example.py @@ -1,3 +1,5 @@ +# Copyright (c) Microsoft Corporation 2015 + from z3 import * x = Real('x') diff --git a/examples/tptp/tptp5.cpp b/examples/tptp/tptp5.cpp index 3b8d2364d8a..0ed92801df9 100644 --- a/examples/tptp/tptp5.cpp +++ b/examples/tptp/tptp5.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include #include diff --git a/examples/tptp/tptp5.h b/examples/tptp/tptp5.h index 69fe79b2891..9486642437e 100644 --- a/examples/tptp/tptp5.h +++ b/examples/tptp/tptp5.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifndef TPTP5_H_ #define TPTP5_H_ diff --git a/examples/tptp/tptp5.lex.cpp b/examples/tptp/tptp5.lex.cpp index 639d9275044..afeebb30a45 100644 --- a/examples/tptp/tptp5.lex.cpp +++ b/examples/tptp/tptp5.lex.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #line 2 "tptp5.lex.cpp" #line 4 "tptp5.lex.cpp" diff --git a/scripts/mk_copyright.py b/scripts/mk_copyright.py new file mode 100644 index 00000000000..4d774cb9613 --- /dev/null +++ b/scripts/mk_copyright.py @@ -0,0 +1,57 @@ +# Copyright (c) 2015 Microsoft Corporation + +import os +import re + +cr = re.compile("Copyright") +aut = re.compile("Automatically generated") + +cr_notice = """ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + +""" + +def has_cr(file): + ins = open(file) + lines = 0 + line = ins.readline() + while line and lines < 20: + m = cr.search(line) + if m: + ins.close() + return True + m = aut.search(line) + if m: + ins.close() + return True + line = ins.readline() + ins.close() + return False + +def add_cr(file): + tmp = "%s.tmp" % file + ins = open(file) + ous = open(tmp,'w') + ous.write(cr_notice) + line = ins.readline() + while line: + ous.write(line) + line = ins.readline() + ins.close() + ous.close() + os.system("move %s %s" % (tmp, file)) + +def add_missing_cr(dir): + for root, dirs, files in os.walk(dir): + for f in files: + if f.endswith('.cpp') or f.endswith('.h') or f.endswith('.c') or f.endswith('.cs'): + path = "%s\\%s" % (root, f) + if not has_cr(path): + print "Missing CR for %s" % path + add_cr(path) + +add_missing_cr('src') +add_missing_cr('examples') diff --git a/scripts/trackall.sh b/scripts/trackall.sh index d8351af248e..5e637100d15 100755 --- a/scripts/trackall.sh +++ b/scripts/trackall.sh @@ -1,7 +1,9 @@ #!/bin/bash +# Copyright (c) 2015 Microsoft Corporation # Script for "cloning" (and tracking) all branches at codeplex. # On Windows, this script must be executed in the "git Bash" console. + for branch in `git branch -a | grep remotes | grep -v HEAD | grep -v master`; do git branch --track ${branch##*/} $branch done diff --git a/src/api/api_context.cpp b/src/api/api_context.cpp index 6e0c3cd82cc..c857be48dea 100644 --- a/src/api/api_context.cpp +++ b/src/api/api_context.cpp @@ -516,6 +516,11 @@ extern "C" { memory::initialize(0); } + void Z3_API Z3_finalize_memory(void) { + LOG_Z3_finalize_memory(); + memory::finalize(); + } + Z3_error_code Z3_API Z3_get_error_code(Z3_context c) { LOG_Z3_get_error_code(c); return mk_c(c)->get_error_code(); diff --git a/src/api/api_fpa.cpp b/src/api/api_fpa.cpp index e7ae685fc6a..e79a04cadd7 100644 --- a/src/api/api_fpa.cpp +++ b/src/api/api_fpa.cpp @@ -712,7 +712,7 @@ extern "C" { unsigned Z3_API Z3_fpa_get_sbits(Z3_context c, Z3_sort s) { Z3_TRY; - LOG_Z3_fpa_get_ebits(c, s); + LOG_Z3_fpa_get_sbits(c, s); RESET_ERROR_CODE(); CHECK_NON_NULL(s, 0); return mk_c(c)->fpautil().get_sbits(to_sort(s)); @@ -765,7 +765,30 @@ extern "C" { mpqm.display_decimal(ss, q, sbits); return mk_c(c)->mk_external_string(ss.str()); Z3_CATCH_RETURN(""); + } + Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(__in Z3_context c, __in Z3_ast t, __out __uint64 * n) { + Z3_TRY; + LOG_Z3_fpa_get_numeral_significand_uint64(c, t, n); + RESET_ERROR_CODE(); + ast_manager & m = mk_c(c)->m(); + mpf_manager & mpfm = mk_c(c)->fpautil().fm(); + unsynch_mpz_manager & mpzm = mpfm.mpz_manager(); + fpa_decl_plugin * plugin = (fpa_decl_plugin*)m.get_plugin(mk_c(c)->get_fpa_fid()); + scoped_mpf val(mpfm); + bool r = plugin->is_numeral(to_expr(t), val); + if (!r) { + SET_ERROR_CODE(Z3_INVALID_ARG); + return 0; + } + const mpz & z = mpfm.sig(val); + if (!mpzm.is_uint64(z)) { + SET_ERROR_CODE(Z3_INVALID_ARG); + return 0; + } + *n = mpzm.get_uint64(z); + return 1; + Z3_CATCH_RETURN(0); } Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(__in Z3_context c, __in Z3_ast t) { @@ -794,7 +817,7 @@ extern "C" { Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(__in Z3_context c, __in Z3_ast t, __out __int64 * n) { Z3_TRY; - LOG_Z3_fpa_get_numeral_exponent_string(c, t); + LOG_Z3_fpa_get_numeral_exponent_int64(c, t, n); RESET_ERROR_CODE(); ast_manager & m = mk_c(c)->m(); mpf_manager & mpfm = mk_c(c)->fpautil().fm(); diff --git a/src/api/dll/dll.cpp b/src/api/dll/dll.cpp index 1730ede23a1..a0bd25d2e6c 100644 --- a/src/api/dll/dll.cpp +++ b/src/api/dll/dll.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifdef _WINDOWS #include diff --git a/src/api/dotnet/FPNum.cs b/src/api/dotnet/FPNum.cs index e85687ccfee..ac1fae5f5c0 100644 --- a/src/api/dotnet/FPNum.cs +++ b/src/api/dotnet/FPNum.cs @@ -59,6 +59,25 @@ public string Significand } } + /// + /// The significand value of a floating-point numeral as a UInt64 + /// + /// + /// This function extracts the significand bits, without the + /// hidden bit or normalization. Throws an exception if the + /// significand does not fit into a UInt64. + /// + public UInt64 SignificandUInt64 + { + get + { + UInt64 result = 0; + if (Native.Z3_fpa_get_numeral_significand_uint64(Context.nCtx, NativeObject, ref result) == 0) + throw new Z3Exception("Significand is not a 64 bit unsigned integer"); + return result; + } + } + /// /// Return the exponent value of a floating-point numeral as a string /// diff --git a/src/api/dotnet/Goal.cs b/src/api/dotnet/Goal.cs index 46d519d3585..5ee44f34bbd 100644 --- a/src/api/dotnet/Goal.cs +++ b/src/api/dotnet/Goal.cs @@ -208,6 +208,21 @@ public override string ToString() return Native.Z3_goal_to_string(Context.nCtx, NativeObject); } + /// + /// Goal to BoolExpr conversion. + /// + /// A string representation of the Goal. + public BoolExpr AsBoolExpr() { + uint n = Size; + if (n == 0) + return Context.MkTrue(); + else if (n == 1) + return Formulas[0]; + else { + return Context.MkAnd(Formulas); + } + } + #region Internal internal Goal(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } diff --git a/src/api/dotnet/InterpolationContext.cs b/src/api/dotnet/InterpolationContext.cs index e6e258b9aad..595023b6996 100644 --- a/src/api/dotnet/InterpolationContext.cs +++ b/src/api/dotnet/InterpolationContext.cs @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + using System; using System.Collections.Generic; using System.Linq; diff --git a/src/api/java/FPNum.java b/src/api/java/FPNum.java index 9a147778a0a..69a44c55922 100644 --- a/src/api/java/FPNum.java +++ b/src/api/java/FPNum.java @@ -43,6 +43,21 @@ public String getSignificand() { return Native.fpaGetNumeralSignificandString(getContext().nCtx(), getNativeObject()); } + /** + * The significand value of a floating-point numeral as a UInt64 + * Remarks: This function extracts the significand bits, without the + * hidden bit or normalization. Throws an exception if the + * significand does not fit into a UInt64. + * @throws Z3Exception + **/ + public long getSignificandUInt64() + { + Native.LongPtr res = new Native.LongPtr(); + if (Native.fpaGetNumeralSignificandUint64(getContext().nCtx(), getNativeObject(), res) ^ true) + throw new Z3Exception("Significand is not a 64 bit unsigned integer"); + return res.value; + } + /** * Return the exponent value of a floating-point numeral as a string * @throws Z3Exception diff --git a/src/api/java/FPSort.java b/src/api/java/FPSort.java index 82e69afbe98..59313fe27ca 100644 --- a/src/api/java/FPSort.java +++ b/src/api/java/FPSort.java @@ -43,7 +43,7 @@ public int getEBits() { * The number of significand bits. */ public int getSBits() { - return Native.fpaGetEbits(getContext().nCtx(), getNativeObject()); + return Native.fpaGetSbits(getContext().nCtx(), getNativeObject()); } } diff --git a/src/api/java/Goal.java b/src/api/java/Goal.java index 18aecb55785..41d4e27aca5 100644 --- a/src/api/java/Goal.java +++ b/src/api/java/Goal.java @@ -221,6 +221,22 @@ public String toString() return "Z3Exception: " + e.getMessage(); } } + + /** + * Goal to BoolExpr conversion. + * + * Returns a string representation of the Goal. + **/ + public BoolExpr AsBoolExpr() { + int n = size(); + if (n == 0) + return getContext().mkTrue(); + else if (n == 1) + return getFormulas()[0]; + else { + return getContext().mkAnd(getFormulas()); + } + } Goal(Context ctx, long obj) { diff --git a/src/api/ml/z3.ml b/src/api/ml/z3.ml index fa6ce6c8157..51eb35e2996 100644 --- a/src/api/ml/z3.ml +++ b/src/api/ml/z3.ml @@ -2059,6 +2059,8 @@ struct (Z3native.fpa_get_numeral_sign (context_gno ctx) (Expr.gno t)) let get_numeral_significand_string ( ctx : context ) ( t : expr ) = (Z3native.fpa_get_numeral_significand_string (context_gno ctx) (Expr.gno t)) + let get_numeral_significand_uint ( ctx : context ) ( t : expr ) = + (Z3native.fpa_get_numeral_significand_uint64 (context_gno ctx) (Expr.gno t)) let get_numeral_exponent_string ( ctx : context ) ( t : expr ) = (Z3native.fpa_get_numeral_exponent_string (context_gno ctx) (Expr.gno t)) let get_numeral_exponent_int ( ctx : context ) ( t : expr ) = @@ -2197,6 +2199,15 @@ struct create ctx (Z3native.mk_goal (context_gno ctx) models unsat_cores proofs) let to_string ( x : goal ) = Z3native.goal_to_string (z3obj_gnc x) (z3obj_gno x) + + let as_expr ( x : goal ) = + let n = get_size x in + if n = 0 then + (Boolean.mk_true (z3obj_gc x)) + else if n = 1 then + (List.hd (get_formulas x)) + else + (Boolean.mk_and (z3obj_gc x) (get_formulas x)) end diff --git a/src/api/ml/z3.mli b/src/api/ml/z3.mli index 2099359fa1c..e0f89565d2a 100644 --- a/src/api/ml/z3.mli +++ b/src/api/ml/z3.mli @@ -2161,6 +2161,12 @@ sig (** Return the significand value of a floating-point numeral as a string. *) val get_numeral_significand_string : context -> Expr.expr -> string + (** Return the significand value of a floating-point numeral as a uint64. + Remark: This function extracts the significand bits, without the + hidden bit or normalization. Throws an exception if the + significand does not fit into a uint64. *) + val get_numeral_significand_uint : context -> Expr.expr -> bool * int + (** Return the exponent value of a floating-point numeral as a string *) val get_numeral_exponent_string : context -> Expr.expr -> string @@ -2647,6 +2653,9 @@ sig (** A string representation of the Goal. *) val to_string : goal -> string + + (** Goal to BoolExpr conversion. *) + val as_expr : goal -> Expr.expr end (** Models diff --git a/src/api/ml/z3_stubs.c b/src/api/ml/z3_stubs.c index 6286e94c7f1..7222158bb3a 100644 --- a/src/api/ml/z3_stubs.c +++ b/src/api/ml/z3_stubs.c @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + /* File generated from z3.idl */ #include diff --git a/src/api/python/z3.py b/src/api/python/z3.py index 16d2eb6ba9a..f6a61731761 100644 --- a/src/api/python/z3.py +++ b/src/api/python/z3.py @@ -5617,7 +5617,7 @@ def __len__(self): sat >>> st = s.statistics() >>> len(st) - 2 + 4 """ return int(Z3_stats_size(self.ctx.ref(), self.stats)) @@ -5631,7 +5631,7 @@ def __getitem__(self, idx): sat >>> st = s.statistics() >>> len(st) - 2 + 4 >>> st[0] ('nlsat propagations', 2) >>> st[1] @@ -5655,7 +5655,7 @@ def keys(self): sat >>> st = s.statistics() >>> st.keys() - ['nlsat propagations', 'nlsat stages'] + ['nlsat propagations', 'nlsat stages', 'max memory', 'memory'] """ return [Z3_stats_get_key(self.ctx.ref(), self.stats, idx) for idx in range(len(self))] @@ -5692,7 +5692,7 @@ def __getattr__(self, name): sat >>> st = s.statistics() >>> st.keys() - ['nlsat propagations', 'nlsat stages'] + ['nlsat propagations', 'nlsat stages', 'max memory', 'memory'] >>> st.nlsat_propagations 2 >>> st.nlsat_stages @@ -8194,23 +8194,24 @@ def FP(name, fpsort, ctx=None): >>> eq(x, x2) True """ - ctx = fpsort.ctx + if isinstance(fpsort, FPSortRef): + ctx = fpsort.ctx + else: + ctx = _get_ctx(ctx) return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx) def FPs(names, fpsort, ctx=None): """Return an array of floating-point constants. - >>> x, y, z = BitVecs('x y z', 16) - >>> x.size() - 16 + >>> x, y, z = FPs('x y z', FPSort(8, 24)) >>> x.sort() - BitVec(16) - >>> Sum(x, y, z) - 0 + x + y + z - >>> Product(x, y, z) - 1*x*y*z - >>> simplify(Product(x, y, z)) - x*y*z + FPSort(8, 24) + >>> x.sbits() + 24 + >>> x.ebits() + 8 + >>> fpMul(RNE(), fpAdd(RNE(), x, y), z) + fpMul(RNE(), fpAdd(RNE(), x, y), z) """ ctx = z3._get_ctx(ctx) if isinstance(names, str): diff --git a/src/api/python/z3test.py b/src/api/python/z3test.py index 9b894d7ad28..38939cebf6f 100644 --- a/src/api/python/z3test.py +++ b/src/api/python/z3test.py @@ -1,3 +1,10 @@ +############################################ +# Copyright (c) 2012 Microsoft Corporation +# +# Z3 Python interface +# +# Author: Leonardo de Moura (leonardo) +############################################ import z3, doctest r = doctest.testmod(z3) diff --git a/src/api/python/z3types.py b/src/api/python/z3types.py index e01b7823873..44b19d33a42 100644 --- a/src/api/python/z3types.py +++ b/src/api/python/z3types.py @@ -1,3 +1,11 @@ +############################################ +# Copyright (c) 2012 Microsoft Corporation +# +# Z3 Python interface +# +# Author: Leonardo de Moura (leonardo) +############################################ + import ctypes, z3core class Z3Exception(Exception): diff --git a/src/api/python/z3util.py b/src/api/python/z3util.py index e0e9aba32e9..38e406723b1 100644 --- a/src/api/python/z3util.py +++ b/src/api/python/z3util.py @@ -1,3 +1,10 @@ +############################################ +# Copyright (c) 2012 Microsoft Corporation +# +# Z3 Python interface +# +# Author: Leonardo de Moura (leonardo) +############################################ """ Usage: import common_z3 as CM_Z3 diff --git a/src/api/z3_api.h b/src/api/z3_api.h index ec321b66d6a..e299fa31a1a 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifndef _Z3_API_H_ #define _Z3_API_H_ @@ -5365,7 +5371,19 @@ END_MLAPI_EXCLUDE */ void Z3_API Z3_reset_memory(void); #endif - + +#ifdef CorML3 + /** + \brief Destroy all allocated resources. + + Any pointers previously returned by the API become invalid. + Can be used for memory leak detection. + + def_API('Z3_finalize_memory', VOID, ()) + */ + void Z3_API Z3_finalize_memory(void); +#endif + /*@}*/ #ifdef CorML3 @@ -6933,7 +6951,7 @@ END_MLAPI_EXCLUDE def_API('Z3_tactic_apply_ex', APPLY_RESULT, (_in(CONTEXT), _in(TACTIC), _in(GOAL), _in(PARAMS))) */ - Z3_apply_result Z3_API Z3_tactic_apply_ex(Z3_context c, Z3_tactic t, Z3_goal g, Z3_params p); + Z3_apply_result Z3_API Z3_tactic_apply_ex(__in Z3_context c, __in Z3_tactic t, __in Z3_goal g, __in Z3_params p); #ifdef CorML3 /** diff --git a/src/api/z3_fpa.h b/src/api/z3_fpa.h index e1bd67d66d2..7813142a304 100644 --- a/src/api/z3_fpa.h +++ b/src/api/z3_fpa.h @@ -858,6 +858,20 @@ extern "C" { */ Z3_string Z3_API Z3_fpa_get_numeral_significand_string(__in Z3_context c, __in Z3_ast t); + /** + \brief Return the significand value of a floating-point numeral as a uint64. + + \param c logical context + \param t a floating-point numeral + + Remarks: This function extracts the significand bits in `t`, without the + hidden bit or normalization. Sets the Z3_INVALID_ARG error code if the + significand does not fit into a uint64. + + def_API('Z3_fpa_get_numeral_significand_uint64', BOOL, (_in(CONTEXT), _in(AST), _out(UINT64))) + */ + Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(__in Z3_context c, __in Z3_ast t, __out __uint64 * n); + /** \brief Return the exponent value of a floating-point numeral as a string diff --git a/src/api/z3_macros.h b/src/api/z3_macros.h index 7a0b6857ca9..cdac41c974b 100644 --- a/src/api/z3_macros.h +++ b/src/api/z3_macros.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifndef __in #define __in #endif diff --git a/src/ast/bv_decl_plugin.cpp b/src/ast/bv_decl_plugin.cpp index b056ded364f..f65462d1b0c 100644 --- a/src/ast/bv_decl_plugin.cpp +++ b/src/ast/bv_decl_plugin.cpp @@ -501,13 +501,17 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p func_decl * r = mk_func_decl(k, bv_size); if (r != 0) { if (arity != r->get_arity()) { - m_manager->raise_exception("declared arity mismatches supplied arity"); - return 0; + if (r->get_info()->is_associative()) + arity = r->get_arity(); + else { + m_manager->raise_exception("declared arity mismatches supplied arity"); + return 0; + } } for (unsigned i = 0; i < arity; ++i) { if (domain[i] != r->get_domain(i)) { m_manager->raise_exception("declared sorts do not match supplied sorts"); - return 0; + return 0; } } return r; @@ -566,6 +570,7 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters, unsigned num_args, expr * const * args, sort * range) { + ast_manager& m = *m_manager; int bv_size; if (k == OP_INT2BV && get_int2bv_size(num_parameters, parameters, bv_size)) { // bv_size is filled in. @@ -589,11 +594,35 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range); } else if (num_args == 0 || !get_bv_size(args[0], bv_size)) { - m_manager->raise_exception("operator is applied to arguments of the wrong sort"); + m.raise_exception("operator is applied to arguments of the wrong sort"); return 0; } func_decl * r = mk_func_decl(k, bv_size); if (r != 0) { + if (num_args != r->get_arity()) { + if (r->get_info()->is_associative()) { + sort * fs = r->get_domain(0); + for (unsigned i = 0; i < num_args; ++i) { + if (m.get_sort(args[i]) != fs) { + m_manager->raise_exception("declared sorts do not match supplied sorts"); + return 0; + } + } + return r; + } + else { + m.raise_exception("declared arity mismatches supplied arity"); + return 0; + } + } + for (unsigned i = 0; i < num_args; ++i) { + if (m.get_sort(args[i]) != r->get_domain(i)) { + std::ostringstream buffer; + buffer << "Argument " << mk_pp(args[i], m) << " at position " << i << " does not match declaration " << mk_pp(r, m); + m.raise_exception(buffer.str().c_str()); + return 0; + } + } return r; } return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range); diff --git a/src/ast/dl_decl_plugin.cpp b/src/ast/dl_decl_plugin.cpp index badf8a59d6a..305ac177966 100644 --- a/src/ast/dl_decl_plugin.cpp +++ b/src/ast/dl_decl_plugin.cpp @@ -44,7 +44,8 @@ namespace datalog { m_num_sym("N"), m_lt_sym("<"), m_le_sym("<="), - m_rule_sym("R") + m_rule_sym("R"), + m_min_sym("min") { } @@ -490,6 +491,66 @@ namespace datalog { return m_manager->mk_func_decl(m_clone_sym, 1, &s, s, info); } + /** + In SMT2 syntax, we can write \c ((_ min R N) v_0 v_1 ... v_k)) where 0 <= N <= k, + R is a relation of sort V_0 x V_1 x ... x V_k and each v_i is a zero-arity function + (also known as a "constant" in SMT2 parlance) whose range is of sort V_i. + + Example: + + (define-sort number_t () (_ BitVec 2)) + (declare-rel numbers (number_t number_t)) + (declare-rel is_min (number_t number_t)) + + (declare-var x number_t) + (declare-var y number_t) + + (rule (numbers #b00 #b11)) + (rule (numbers #b00 #b01)) + + (rule (=> (and (numbers x y) ((_ min numbers 1) x y)) (is_min x y))) + + This says that we want to find the mininum y grouped by x. + */ + func_decl * dl_decl_plugin::mk_min(decl_kind k, unsigned num_parameters, parameter const * parameters) { + if (num_parameters < 2) { + m_manager->raise_exception("invalid min aggregate definition due to missing parameters"); + return 0; + } + + parameter const & relation_parameter = parameters[0]; + if (!relation_parameter.is_ast() || !is_func_decl(relation_parameter.get_ast())) { + m_manager->raise_exception("invalid min aggregate definition, first parameter is not a function declaration"); + return 0; + } + + func_decl* f = to_func_decl(relation_parameter.get_ast()); + if (!m_manager->is_bool(f->get_range())) { + m_manager->raise_exception("invalid min aggregate definition, first paramater must be a predicate"); + return 0; + } + + parameter const & min_col_parameter = parameters[1]; + if (!min_col_parameter.is_int()) { + m_manager->raise_exception("invalid min aggregate definition, second parameter must be an integer"); + return 0; + } + + if (min_col_parameter.get_int() < 0) { + m_manager->raise_exception("invalid min aggregate definition, second parameter must be non-negative"); + return 0; + } + + if ((unsigned)min_col_parameter.get_int() >= f->get_arity()) { + m_manager->raise_exception("invalid min aggregate definition, second parameter exceeds the arity of the relation"); + return 0; + } + + func_decl_info info(m_family_id, k, num_parameters, parameters); + SASSERT(f->get_info() == 0); + return m_manager->mk_func_decl(m_min_sym, f->get_arity(), f->get_domain(), f->get_range(), info); + } + func_decl * dl_decl_plugin::mk_func_decl( decl_kind k, unsigned num_parameters, parameter const * parameters, unsigned arity, sort * const * domain, sort * range) { @@ -617,6 +678,9 @@ namespace datalog { break; } + case OP_DL_MIN: + return mk_min(k, num_parameters, parameters); + default: m_manager->raise_exception("operator not recognized"); return 0; @@ -627,7 +691,7 @@ namespace datalog { } void dl_decl_plugin::get_op_names(svector & op_names, symbol const & logic) { - + op_names.push_back(builtin_name(m_min_sym.bare_str(), OP_DL_MIN)); } void dl_decl_plugin::get_sort_names(svector & sort_names, symbol const & logic) { diff --git a/src/ast/dl_decl_plugin.h b/src/ast/dl_decl_plugin.h index 65b00235cf8..e3bc4dd6312 100644 --- a/src/ast/dl_decl_plugin.h +++ b/src/ast/dl_decl_plugin.h @@ -50,6 +50,7 @@ namespace datalog { OP_DL_LT, OP_DL_REP, OP_DL_ABS, + OP_DL_MIN, LAST_RA_OP }; @@ -71,6 +72,7 @@ namespace datalog { symbol m_lt_sym; symbol m_le_sym; symbol m_rule_sym; + symbol m_min_sym; bool check_bounds(char const* msg, unsigned low, unsigned up, unsigned val) const; bool check_domain(unsigned low, unsigned up, unsigned val) const; @@ -94,12 +96,69 @@ namespace datalog { func_decl * mk_compare(decl_kind k, symbol const& sym, sort*const* domain); func_decl * mk_clone(sort* r); func_decl * mk_rule(unsigned arity); + func_decl * mk_min(decl_kind k, unsigned num_parameters, parameter const * parameters); sort * mk_finite_sort(unsigned num_params, parameter const* params); sort * mk_relation_sort(unsigned num_params, parameter const* params); sort * mk_rule_sort(); public: + /** + Is \c decl a min aggregation function? + */ + static bool is_aggregate(const func_decl* const decl) + { + return decl->get_decl_kind() == OP_DL_MIN; + } + + /** + \pre: is_aggregate(aggregate) + + \returns function declaration of predicate which is subject to min aggregation function + */ + static func_decl * min_func_decl(const func_decl* const aggregate) + { + SASSERT(is_aggregate(aggregate)); + parameter const & relation_parameter = aggregate->get_parameter(0); + return to_func_decl(relation_parameter.get_ast()); + } + + /** + \pre: is_aggregate(aggregate) + + \returns column identifier (starting at zero) which is minimized by aggregation function + */ + static unsigned min_col(const func_decl* const aggregate) + { + SASSERT(is_aggregate(aggregate)); + return (unsigned)aggregate->get_parameter(1).get_int(); + } + + /** + \pre: is_aggregate(aggregate) + + \returns column identifiers for the "group by" in the given min aggregation function + */ + static unsigned_vector group_by_cols(const func_decl* const aggregate) + { + SASSERT(is_aggregate(aggregate)); + unsigned _min_col = min_col(aggregate); + if (aggregate->get_arity() == 0U) + return unsigned_vector(); + + unsigned col_num = 0; + unsigned_vector cols(aggregate->get_arity() - 1U); + for (unsigned i = 0; i < cols.size(); ++i, ++col_num) + { + if (col_num == _min_col) + ++col_num; + + cols[i] = col_num; + } + + return cols; + } + dl_decl_plugin(); virtual ~dl_decl_plugin() {} diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index 75e8dfd990d..baba7b701db 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -93,6 +93,20 @@ void fpa2bv_converter::mk_ite(expr * c, expr * t, expr * f, expr_ref & result) { mk_fp(sgn, e, s, result); } +void fpa2bv_converter::mk_distinct(func_decl * f, unsigned num, expr * const * args, expr_ref & result) { + // Note: in SMT there is only one NaN, so multiple of them are considered + // equal, thus (distinct NaN NaN) is false, even if the two NaNs have + // different bitwise representations (see also mk_eq). + result = m.mk_true(); + for (unsigned i = 0; i < num; i++) { + for (unsigned j = i+1; j < num; j++) { + expr_ref eq(m); + mk_eq(args[i], args[j], eq); + m_simp.mk_and(result, m.mk_not(eq), result); + } + } +} + void fpa2bv_converter::mk_numeral(func_decl * f, unsigned num, expr * const * args, expr_ref & result) { SASSERT(num == 0); SASSERT(f->get_num_parameters() == 1); @@ -1403,14 +1417,20 @@ void fpa2bv_converter::mk_fma(func_decl * f, unsigned num, expr * const * args, expr * res_sgn_or_args[3] = { res_sgn_c1, res_sgn_c2, res_sgn_c3 }; res_sgn = m_bv_util.mk_bv_or(3, res_sgn_or_args); - sticky_raw = m_bv_util.mk_extract(sbits-5, 0, sig_abs); - sticky = m_bv_util.mk_zero_extend(sbits+3, m.mk_app(bvfid, OP_BREDOR, sticky_raw.get())); + if (sbits > 5) { + sticky_raw = m_bv_util.mk_extract(sbits - 5, 0, sig_abs); + sticky = m_bv_util.mk_zero_extend(sbits + 3, m.mk_app(bvfid, OP_BREDOR, sticky_raw.get())); + expr * res_or_args[2] = { m_bv_util.mk_extract(2 * sbits - 1, sbits - 4, sig_abs), sticky }; + res_sig = m_bv_util.mk_bv_or(2, res_or_args); + } + else { + unsigned too_short = 6 - sbits; + sig_abs = m_bv_util.mk_concat(sig_abs, m_bv_util.mk_numeral(0, too_short)); + res_sig = m_bv_util.mk_extract(sbits + 3, 0, sig_abs); + } dbg_decouple("fpa2bv_fma_add_sum_sticky", sticky); + SASSERT(m_bv_util.get_bv_size(res_sig) == sbits + 4); - expr * res_or_args[2] = { m_bv_util.mk_extract(2*sbits-1, sbits-4, sig_abs), sticky }; - res_sig = m_bv_util.mk_bv_or(2, res_or_args); - SASSERT(m_bv_util.get_bv_size(res_sig) == sbits+4); - expr_ref is_zero_sig(m), nil_sbits4(m); nil_sbits4 = m_bv_util.mk_numeral(0, sbits+4); m_simp.mk_eq(res_sig, nil_sbits4, is_zero_sig); @@ -1761,11 +1781,19 @@ void fpa2bv_converter::mk_round_to_integral(func_decl * f, unsigned num, expr * m_simp.mk_ite(c52, v52, res_sig, res_sig); m_simp.mk_ite(c51, v51, res_sig, res_sig); res_sig = m_bv_util.mk_concat(res_sig, m_bv_util.mk_numeral(0, 3)); // rounding bits are all 0. - res_exp = m_bv_util.mk_bv_add(m_bv_util.mk_zero_extend(2, res_exp), m_bv_util.mk_extract(ebits+1, 0, shift)); + + SASSERT(m_bv_util.get_bv_size(res_exp) == ebits); + SASSERT(m_bv_util.get_bv_size(shift) == sbits + 1); + + expr_ref e_shift(m); + e_shift = (ebits + 2 <= sbits + 1) ? m_bv_util.mk_extract(ebits + 1, 0, shift) : + m_bv_util.mk_sign_extend((ebits + 2) - (sbits + 1), shift); + SASSERT(m_bv_util.get_bv_size(e_shift) == ebits + 2); + res_exp = m_bv_util.mk_bv_add(m_bv_util.mk_zero_extend(2, res_exp), e_shift); SASSERT(m_bv_util.get_bv_size(res_sgn) == 1); - SASSERT(m_bv_util.get_bv_size(res_sig) == sbits+4); - SASSERT(m_bv_util.get_bv_size(res_exp) == ebits+2); + SASSERT(m_bv_util.get_bv_size(res_sig) == sbits + 4); + SASSERT(m_bv_util.get_bv_size(res_exp) == ebits + 2); // CMW: We use the rounder for normalization. round(f->get_range(), rm, res_sgn, res_sig, res_exp, v6); @@ -2953,9 +2981,8 @@ void fpa2bv_converter::mk_to_sbv(func_decl * f, unsigned num, expr * const * arg shift_abs = m.mk_ite(m_bv_util.mk_sle(shift, bv0_e2), shift_neg, shift); SASSERT(m_bv_util.get_bv_size(shift) == ebits + 2); SASSERT(m_bv_util.get_bv_size(shift_neg) == ebits + 2); - SASSERT(m_bv_util.get_bv_size(shift_abs) == ebits + 2); - dbg_decouple("fpa2bv_to_sbv_shift", shift); - dbg_decouple("fpa2bv_to_sbv_shift_abs", shift_abs); + SASSERT(m_bv_util.get_bv_size(shift_abs) == ebits + 2); + dbg_decouple("fpa2bv_to_sbv_shift", shift); // sig is of the form +- [1].[sig][r][g][s] ... and at least bv_sz + 3 long // [1][ ... sig ... ][r][g][ ... s ...] @@ -2964,34 +2991,48 @@ void fpa2bv_converter::mk_to_sbv(func_decl * f, unsigned num, expr * const * arg max_shift = m_bv_util.mk_numeral(sig_sz, sig_sz); shift_abs = m_bv_util.mk_zero_extend(sig_sz - ebits - 2, shift_abs); SASSERT(m_bv_util.get_bv_size(shift_abs) == sig_sz); + dbg_decouple("fpa2bv_to_sbv_shift_abs", shift_abs); expr_ref c_in_limits(m); c_in_limits = m_bv_util.mk_sle(shift, m_bv_util.mk_numeral(0, ebits + 2)); dbg_decouple("fpa2bv_to_sbv_in_limits", c_in_limits); - expr_ref shifted_sig(m); - shifted_sig = m_bv_util.mk_bv_lshr(sig, shift_abs); - dbg_decouple("fpa2bv_to_sbv_shifted_sig", shifted_sig); + expr_ref huge_sig(m), huge_shift(m), huge_shifted_sig(m); + huge_sig = m_bv_util.mk_concat(sig, m_bv_util.mk_numeral(0, sig_sz)); + huge_shift = m_bv_util.mk_concat(m_bv_util.mk_numeral(0, sig_sz), shift_abs); + huge_shifted_sig = m_bv_util.mk_bv_lshr(huge_sig, huge_shift); + dbg_decouple("fpa2bv_to_sbv_huge_shifted_sig", huge_shifted_sig); + SASSERT(m_bv_util.get_bv_size(huge_shifted_sig) == 2 * sig_sz); + + expr_ref upper_hss(m), lower_hss(m); + upper_hss = m_bv_util.mk_extract(2 * sig_sz - 1, sig_sz + 1, huge_shifted_sig); + lower_hss = m_bv_util.mk_extract(sig_sz, 0, huge_shifted_sig); + SASSERT(m_bv_util.get_bv_size(upper_hss) == sig_sz - 1); + SASSERT(m_bv_util.get_bv_size(lower_hss) == sig_sz + 1); + dbg_decouple("fpa2bv_to_sbv_upper_hss", upper_hss); + dbg_decouple("fpa2bv_to_sbv_lower_hss", lower_hss); expr_ref last(m), round(m), sticky(m); - last = m_bv_util.mk_extract(sig_sz - bv_sz - 0, sig_sz - bv_sz - 0, shifted_sig); - round = m_bv_util.mk_extract(sig_sz - bv_sz - 1, sig_sz - bv_sz - 1, shifted_sig); - sticky = m.mk_ite(m.mk_eq(m_bv_util.mk_extract(sig_sz - bv_sz - 2, 0, shifted_sig), - m_bv_util.mk_numeral(0, sig_sz - (bv_sz + 3) + 2)), - bv0, - bv1); + last = m_bv_util.mk_extract(1, 1, upper_hss); + round = m_bv_util.mk_extract(0, 0, upper_hss); + sticky = m.mk_app(m_bv_util.get_fid(), OP_BREDOR, lower_hss.get()); dbg_decouple("fpa2bv_to_sbv_last", last); dbg_decouple("fpa2bv_to_sbv_round", round); dbg_decouple("fpa2bv_to_sbv_sticky", sticky); + expr_ref upper_hss_w_sticky(m); + upper_hss_w_sticky = m_bv_util.mk_concat(upper_hss, sticky); + dbg_decouple("fpa2bv_to_sbv_upper_hss_w_sticky", upper_hss_w_sticky); + SASSERT(m_bv_util.get_bv_size(upper_hss_w_sticky) == sig_sz); + expr_ref rounding_decision(m); rounding_decision = mk_rounding_decision(rm, sgn, last, round, sticky); SASSERT(m_bv_util.get_bv_size(rounding_decision) == 1); dbg_decouple("fpa2bv_to_sbv_rounding_decision", rounding_decision); expr_ref unrounded_sig(m), pre_rounded(m), inc(m); - unrounded_sig = m_bv_util.mk_zero_extend(1, m_bv_util.mk_extract(sig_sz - 1, sig_sz - bv_sz, shifted_sig)); - inc = m_bv_util.mk_zero_extend(1, m_bv_util.mk_zero_extend(bv_sz - 1, rounding_decision)); + unrounded_sig = m_bv_util.mk_extract(sig_sz - 1, sig_sz - bv_sz - 1, upper_hss_w_sticky); + inc = m_bv_util.mk_zero_extend(bv_sz, rounding_decision); pre_rounded = m_bv_util.mk_bv_add(unrounded_sig, inc); dbg_decouple("fpa2bv_to_sbv_inc", inc); dbg_decouple("fpa2bv_to_sbv_unrounded_sig", unrounded_sig); @@ -3409,6 +3450,17 @@ void fpa2bv_converter::dbg_decouple(const char * prefix, expr_ref & e) { } expr_ref fpa2bv_converter::mk_rounding_decision(expr * rm, expr * sgn, expr * last, expr * round, expr * sticky) { + expr_ref rmr(rm, m); + expr_ref sgnr(sgn, m); + expr_ref lastr(last, m); + expr_ref roundr(round, m); + expr_ref stickyr(sticky, m); + dbg_decouple("fpa2bv_rnd_dec_rm", rmr); + dbg_decouple("fpa2bv_rnd_dec_sgn", sgnr); + dbg_decouple("fpa2bv_rnd_dec_last", lastr); + dbg_decouple("fpa2bv_rnd_dec_round", roundr); + dbg_decouple("fpa2bv_rnd_dec_sticky", stickyr); + expr_ref last_or_sticky(m), round_or_sticky(m), not_last(m), not_round(m), not_sticky(m), not_lors(m), not_rors(m), not_sgn(m); expr * last_sticky[2] = { last, sticky }; expr * round_sticky[2] = { round, sticky }; @@ -3446,6 +3498,7 @@ expr_ref fpa2bv_converter::mk_rounding_decision(expr * rm, expr * sgn, expr * la m_simp.mk_ite(rm_is_away, inc_taway, inc_c3, inc_c2); m_simp.mk_ite(rm_is_even, inc_teven, inc_c2, res); + dbg_decouple("fpa2bv_rnd_dec_res", res); return res; } diff --git a/src/ast/fpa/fpa2bv_converter.h b/src/ast/fpa/fpa2bv_converter.h index 4b3c1a6ca19..b0881a364ff 100644 --- a/src/ast/fpa/fpa2bv_converter.h +++ b/src/ast/fpa/fpa2bv_converter.h @@ -80,6 +80,7 @@ class fpa2bv_converter { void mk_eq(expr * a, expr * b, expr_ref & result); void mk_ite(expr * c, expr * t, expr * f, expr_ref & result); + void mk_distinct(func_decl * f, unsigned num, expr * const * args, expr_ref & result); void mk_rounding_mode(func_decl * f, expr_ref & result); void mk_numeral(func_decl * f, unsigned num, expr * const * args, expr_ref & result); diff --git a/src/ast/fpa/fpa2bv_rewriter.h b/src/ast/fpa/fpa2bv_rewriter.h index ed885a4cc27..fa88c227c3b 100644 --- a/src/ast/fpa/fpa2bv_rewriter.h +++ b/src/ast/fpa/fpa2bv_rewriter.h @@ -103,8 +103,7 @@ struct fpa2bv_rewriter_cfg : public default_rewriter_cfg { } return BR_FAILED; } - - if (m().is_ite(f)) { + else if (m().is_ite(f)) { SASSERT(num == 3); if (m_conv.is_float(args[1])) { m_conv.mk_ite(args[0], args[1], args[2], result); @@ -112,6 +111,14 @@ struct fpa2bv_rewriter_cfg : public default_rewriter_cfg { } return BR_FAILED; } + else if (m().is_distinct(f)) { + sort * ds = f->get_domain()[0]; + if (m_conv.is_float(ds) || m_conv.is_rm(ds)) { + m_conv.mk_distinct(f, num, args, result); + return BR_DONE; + } + return BR_FAILED; + } if (m_conv.is_float_family(f)) { switch (f->get_decl_kind()) { diff --git a/src/ast/func_decl_dependencies.cpp b/src/ast/func_decl_dependencies.cpp index 76f1e38891f..d53c2d9b1f4 100644 --- a/src/ast/func_decl_dependencies.cpp +++ b/src/ast/func_decl_dependencies.cpp @@ -154,7 +154,7 @@ class func_decl_dependencies::top_sort { case OPEN: set_color(cf, IN_PROGRESS); if (visit_children(cf)) { - SASSERT(m_todo.back() == f); + SASSERT(m_todo.back() == cf); m_todo.pop_back(); set_color(cf, CLOSED); } diff --git a/src/ast/proof_checker/proof_checker.cpp b/src/ast/proof_checker/proof_checker.cpp index 41c43b26c06..16546db1e1b 100644 --- a/src/ast/proof_checker/proof_checker.cpp +++ b/src/ast/proof_checker/proof_checker.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "proof_checker.h" #include "ast_ll_pp.h" #include "ast_pp.h" diff --git a/src/ast/rewriter/expr_safe_replace.cpp b/src/ast/rewriter/expr_safe_replace.cpp index 37fcdfe6a99..b4357796030 100644 --- a/src/ast/rewriter/expr_safe_replace.cpp +++ b/src/ast/rewriter/expr_safe_replace.cpp @@ -49,17 +49,23 @@ void expr_safe_replace::operator()(expr* e, expr_ref& res) { app* c = to_app(a); unsigned n = c->get_num_args(); m_args.reset(); + bool arg_differs = false; for (unsigned i = 0; i < n; ++i) { if (m_cache.find(c->get_arg(i), d)) { m_args.push_back(d); + arg_differs |= c->get_arg(i) != d; } else { m_todo.push_back(c->get_arg(i)); } } if (m_args.size() == n) { - b = m.mk_app(c->get_decl(), m_args.size(), m_args.c_ptr()); - m_refs.push_back(b); + if (arg_differs) { + b = m.mk_app(c->get_decl(), m_args.size(), m_args.c_ptr()); + m_refs.push_back(b); + } else { + b = a; + } m_cache.insert(a, b); m_todo.pop_back(); } diff --git a/src/ast/simplifier/bv_elim.cpp b/src/ast/simplifier/bv_elim.cpp index fc4e7534b41..8dc2671cacd 100644 --- a/src/ast/simplifier/bv_elim.cpp +++ b/src/ast/simplifier/bv_elim.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "bv_elim.h" #include "bv_decl_plugin.h" #include "var_subst.h" diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp index 50afc173500..c8d5e8cab92 100644 --- a/src/cmd_context/cmd_context.cpp +++ b/src/cmd_context/cmd_context.cpp @@ -621,6 +621,7 @@ void cmd_context::init_manager_core(bool new_manager) { register_plugin(symbol("seq"), alloc(seq_decl_plugin), logic_has_seq()); register_plugin(symbol("pb"), alloc(pb_decl_plugin), !has_logic()); register_plugin(symbol("fpa"), alloc(fpa_decl_plugin), logic_has_fpa()); + register_plugin(symbol("datalog_relation"), alloc(datalog::dl_decl_plugin), !has_logic()); } else { // the manager was created by an external module diff --git a/src/math/realclosure/realclosure.cpp b/src/math/realclosure/realclosure.cpp index 84ba606fd60..1ca8823a1ec 100644 --- a/src/math/realclosure/realclosure.cpp +++ b/src/math/realclosure/realclosure.cpp @@ -4075,7 +4075,7 @@ namespace realclosure { void refine_rational_interval(rational_value * v, unsigned prec) { mpbqi & i = interval(v); - if (!i.lower_is_open() && !i.lower_is_open()) { + if (!i.lower_is_open() && !i.upper_is_open()) { SASSERT(bqm().eq(i.lower(), i.upper())); return; } diff --git a/src/muz/base/dl_boogie_proof.cpp b/src/muz/base/dl_boogie_proof.cpp index 42d21dfb9d0..cc0e28e2a6a 100644 --- a/src/muz/base/dl_boogie_proof.cpp +++ b/src/muz/base/dl_boogie_proof.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + /** Example from Boogie: diff --git a/src/muz/base/dl_boogie_proof.h b/src/muz/base/dl_boogie_proof.h index 6c8fbbae3e1..0f829dbdfc2 100644 --- a/src/muz/base/dl_boogie_proof.h +++ b/src/muz/base/dl_boogie_proof.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + /** output :: derivation model diff --git a/src/muz/base/dl_rule.h b/src/muz/base/dl_rule.h index bdca80d0b20..468b9f88c39 100644 --- a/src/muz/base/dl_rule.h +++ b/src/muz/base/dl_rule.h @@ -346,6 +346,13 @@ namespace datalog { bool is_neg_tail(unsigned i) const { SASSERT(i < m_tail_size); return GET_TAG(m_tail[i]) == 1; } + /** + A predicate P(Xj) can be annotated by adding an interpreted predicate of the form ((_ min P N) ...) + where N is the column number that should be used for the min aggregation function. + Such an interpreted predicate is an example for which this function returns true. + */ + bool is_min_tail(unsigned i) const { return dl_decl_plugin::is_aggregate(get_tail(i)->get_decl()); } + /** Check whether predicate p is in the interpreted tail. diff --git a/src/muz/base/dl_rule_set.cpp b/src/muz/base/dl_rule_set.cpp index ad3b512a3ec..555b592efea 100644 --- a/src/muz/base/dl_rule_set.cpp +++ b/src/muz/base/dl_rule_set.cpp @@ -400,7 +400,7 @@ namespace datalog { SASSERT(!is_closed()); //the rule_set is not already closed m_deps.populate(*this); m_stratifier = alloc(rule_stratifier, m_deps); - if (!stratified_negation()) { + if (!stratified_negation() || !check_min()) { m_stratifier = 0; m_deps.reset(); return false; @@ -441,6 +441,49 @@ namespace datalog { return true; } + bool rule_set::check_min() { + // For now, we check the following: + // + // if a min aggregation function occurs in an SCC, is this SCC + // free of any other non-monotonic functions, e.g. negation? + const unsigned NEG_BIT = 1U << 0; + const unsigned MIN_BIT = 1U << 1; + + ptr_vector::const_iterator it = m_rules.c_ptr(); + ptr_vector::const_iterator end = m_rules.c_ptr() + m_rules.size(); + unsigned_vector component_status(m_stratifier->get_strats().size()); + + for (; it != end; it++) { + rule * r = *it; + app * head = r->get_head(); + func_decl * head_decl = head->get_decl(); + unsigned head_strat = get_predicate_strat(head_decl); + unsigned n = r->get_tail_size(); + for (unsigned i = 0; i < n; i++) { + func_decl * tail_decl = r->get_tail(i)->get_decl(); + unsigned strat = get_predicate_strat(tail_decl); + + if (r->is_neg_tail(i)) { + SASSERT(strat < component_status.size()); + component_status[strat] |= NEG_BIT; + } + + if (r->is_min_tail(i)) { + SASSERT(strat < component_status.size()); + component_status[strat] |= MIN_BIT; + } + } + } + + const unsigned CONFLICT = NEG_BIT | MIN_BIT; + for (unsigned k = 0; k < component_status.size(); ++k) { + if (component_status[k] == CONFLICT) + return false; + } + + return true; + } + void rule_set::replace_rules(const rule_set & src) { if (this != &src) { reset(); diff --git a/src/muz/base/dl_rule_set.h b/src/muz/base/dl_rule_set.h index e13d92105d7..a7d09b099b6 100644 --- a/src/muz/base/dl_rule_set.h +++ b/src/muz/base/dl_rule_set.h @@ -179,6 +179,7 @@ namespace datalog { void compute_deps(); void compute_tc_deps(); bool stratified_negation(); + bool check_min(); public: rule_set(context & ctx); rule_set(const rule_set & rs); diff --git a/src/muz/base/hnf.h b/src/muz/base/hnf.h index 9dc7cccd9ed..4d3edcb68e2 100644 --- a/src/muz/base/hnf.h +++ b/src/muz/base/hnf.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + /*-- Module Name: diff --git a/src/muz/base/proof_utils.cpp b/src/muz/base/proof_utils.cpp index d4a8ab22be7..4bfbf336516 100644 --- a/src/muz/base/proof_utils.cpp +++ b/src/muz/base/proof_utils.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "dl_util.h" #include "proof_utils.h" #include "ast_smt2_pp.h" diff --git a/src/muz/base/rule_properties.cpp b/src/muz/base/rule_properties.cpp index 5d1aff44e33..619f88e3b49 100644 --- a/src/muz/base/rule_properties.cpp +++ b/src/muz/base/rule_properties.cpp @@ -142,7 +142,7 @@ void rule_properties::check_existential_tail() { todo.push_back(e2); } else if (is_quantifier(e)) { - todo.push_back(to_quantifier(e)->get_expr()); + tocheck.push_back(to_quantifier(e)->get_expr()); } else if ((m.is_eq(e, e1, e2) || m.is_iff(e, e1, e2)) && m.is_true(e1)) { @@ -194,7 +194,6 @@ void rule_properties::operator()(app* n) { } } else { - std::cout << mk_pp(n, m) << "\n"; } } diff --git a/src/muz/fp/datalog_parser.cpp b/src/muz/fp/datalog_parser.cpp index 58bc79e7a2b..f1080676de7 100644 --- a/src/muz/fp/datalog_parser.cpp +++ b/src/muz/fp/datalog_parser.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include"datalog_parser.h" #include"string_buffer.h" #include"str_hashtable.h" @@ -95,9 +101,10 @@ class line_reader { resize_data(0); #if _WINDOWS errno_t err = fopen_s(&m_file, fname, "rb"); - m_ok = err == 0; + m_ok = (m_file != NULL) && (err == 0); #else m_file = fopen(fname, "rb"); + m_ok = (m_file != NULL); #endif } ~line_reader() { diff --git a/src/muz/rel/check_relation.cpp b/src/muz/rel/check_relation.cpp index 20364d5d5f8..60ca6c0bef0 100644 --- a/src/muz/rel/check_relation.cpp +++ b/src/muz/rel/check_relation.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "check_relation.h" #include "dl_relation_manager.h" #include "qe_util.h" diff --git a/src/muz/rel/dl_base.cpp b/src/muz/rel/dl_base.cpp index 95efccce85d..6dc7f2f6e57 100644 --- a/src/muz/rel/dl_base.cpp +++ b/src/muz/rel/dl_base.cpp @@ -485,4 +485,125 @@ namespace datalog { brw.mk_or(disjs.size(), disjs.c_ptr(), fml); } + class table_plugin::min_fn : public table_min_fn{ + table_signature m_sig; + const unsigned_vector m_group_by_cols; + const unsigned m_col; + public: + min_fn(const table_signature & t_sig, const unsigned_vector& group_by_cols, const unsigned col) + : m_sig(t_sig), + m_group_by_cols(group_by_cols), + m_col(col) {} + + virtual table_base* operator()(table_base const& t) { + //return reference_implementation(t); + return reference_implementation_with_hash(t); + } + + private: + + /** + Reference implementation with negation: + + T1 = join(T, T) by group_cols + T2 = { (t1,t2) in T1 | t1[col] > t2[col] } + T3 = { t1 | (t1,t2) in T2 } + T4 = T \ T3 + + The point of this reference implementation is to show + that the minimum requires negation (set difference). + This is relevant for fixed point computations. + */ + virtual table_base * reference_implementation(const table_base & t) { + relation_manager & manager = t.get_manager(); + scoped_ptr join_fn = manager.mk_join_fn(t, t, m_group_by_cols, m_group_by_cols); + scoped_rel join_table = (*join_fn)(t, t); + + table_base::iterator join_table_it = join_table->begin(); + table_base::iterator join_table_end = join_table->end(); + table_fact row; + + table_element i, j; + + for (; join_table_it != join_table_end; ++join_table_it) { + join_table_it->get_fact(row); + i = row[m_col]; + j = row[t.num_columns() + m_col]; + + if (i > j) { + continue; + } + + join_table->remove_fact(row); + } + + unsigned_vector cols(t.num_columns()); + for (unsigned k = 0; k < cols.size(); ++k) { + cols[k] = cols.size() + k; + SASSERT(cols[k] < join_table->num_columns()); + } + + scoped_ptr project_fn = manager.mk_project_fn(*join_table, cols); + scoped_rel gt_table = (*project_fn)(*join_table); + + for (unsigned k = 0; k < cols.size(); ++k) { + cols[k] = k; + SASSERT(cols[k] < t.num_columns()); + SASSERT(cols[k] < gt_table->num_columns()); + } + + table_base * result = t.clone(); + scoped_ptr diff_fn = manager.mk_filter_by_negation_fn(*result, *gt_table, cols, cols); + (*diff_fn)(*result, *gt_table); + return result; + } + + typedef map < table_fact, table_element, svector_hash_proc, + vector_eq_proc > group_map; + + // Thanks to Nikolaj who kindly helped with the second reference implementation! + virtual table_base * reference_implementation_with_hash(const table_base & t) { + group_map group; + table_base::iterator it = t.begin(); + table_base::iterator end = t.end(); + table_fact row, row2; + table_element current_value, min_value; + for (; it != end; ++it) { + it->get_fact(row); + current_value = row[m_col]; + group_by(row, row2); + group_map::entry* entry = group.find_core(row2); + if (!entry) { + group.insert(row2, current_value); + } + else if (entry->get_data().m_value > current_value) { + entry->get_data().m_value = current_value; + } + } + table_base* result = t.get_plugin().mk_empty(m_sig); + table_base::iterator it2 = t.begin(); + for (; it2 != end; ++it2) { + it2->get_fact(row); + current_value = row[m_col]; + group_by(row, row2); + VERIFY(group.find(row2, min_value)); + if (min_value == current_value) { + result->add_fact(row); + } + } + return result; + } + + void group_by(table_fact const& in, table_fact& out) { + out.reset(); + for (unsigned i = 0; i < m_group_by_cols.size(); ++i) { + out.push_back(in[m_group_by_cols[i]]); + } + } + }; + + table_min_fn * table_plugin::mk_min_fn(const table_base & t, + unsigned_vector & group_by_cols, const unsigned col) { + return alloc(table_plugin::min_fn, t.get_signature(), group_by_cols, col); + } } diff --git a/src/muz/rel/dl_base.h b/src/muz/rel/dl_base.h index 268cc602e83..6ab1b2a96c9 100644 --- a/src/muz/rel/dl_base.h +++ b/src/muz/rel/dl_base.h @@ -192,6 +192,29 @@ namespace datalog { virtual base_object * operator()(const base_object & t1, const base_object & t2) = 0; }; + /** + \brief Aggregate minimum value + + Informally, we want to group rows in a table \c t by \c group_by_cols and + return the minimum value in column \c col among each group. + + Let \c t be a table with N columns. + Let \c group_by_cols be a set of column identifers for table \c t such that |group_by_cols| < N. + Let \c col be a column identifier for table \c t such that \c col is not in \c group_by_cols. + + Let R_col be a set of rows in table \c t such that, for all rows r_i, r_j in R_col + and column identifiers k in \c group_by_cols, r_i[k] = r_j[k]. + + For each R_col, we want to restrict R_col to those rows whose value in column \c col is minimal. + + min_fn(R, group_by_cols, col) = + { row in R | forall row' in R . row'[group_by_cols] = row[group_by_cols] => row'[col] >= row[col] } + */ + class min_fn : public base_fn { + public: + virtual base_object * operator()(const base_object & t) = 0; + }; + class transformer_fn : public base_fn { public: virtual base_object * operator()(const base_object & t) = 0; @@ -856,6 +879,7 @@ namespace datalog { typedef table_infrastructure::base_fn base_table_fn; typedef table_infrastructure::join_fn table_join_fn; + typedef table_infrastructure::min_fn table_min_fn; typedef table_infrastructure::transformer_fn table_transformer_fn; typedef table_infrastructure::union_fn table_union_fn; typedef table_infrastructure::mutator_fn table_mutator_fn; @@ -1020,6 +1044,7 @@ namespace datalog { class table_plugin : public table_infrastructure::plugin_object { friend class relation_manager; + class min_fn; protected: table_plugin(symbol const& n, relation_manager & manager) : plugin_object(n, manager) {} public: @@ -1027,6 +1052,9 @@ namespace datalog { virtual bool can_handle_signature(const table_signature & s) { return s.functional_columns()==0; } protected: + virtual table_min_fn * mk_min_fn(const table_base & t, + unsigned_vector & group_by_cols, const unsigned col); + /** If the returned value is non-zero, the returned object must take ownership of \c mapper. Otherwise \c mapper must remain unmodified. diff --git a/src/muz/rel/dl_compiler.cpp b/src/muz/rel/dl_compiler.cpp index 59ba260a456..c35985e9857 100644 --- a/src/muz/rel/dl_compiler.cpp +++ b/src/muz/rel/dl_compiler.cpp @@ -73,6 +73,12 @@ namespace datalog { vars.get_cols2(), removed_cols.size(), removed_cols.c_ptr(), result)); } + void compiler::make_min(reg_idx source, reg_idx & target, const unsigned_vector & group_by_cols, + const unsigned min_col, instruction_block & acc) { + target = get_register(m_reg_signatures[source], true, source); + acc.push_back(instruction::mk_min(source, target, group_by_cols, min_col)); + } + void compiler::make_filter_interpreted_and_project(reg_idx src, app_ref & cond, const unsigned_vector & removed_cols, reg_idx & result, bool reuse, instruction_block & acc) { SASSERT(!removed_cols.empty()); @@ -440,6 +446,30 @@ namespace datalog { get_local_indexes_for_projection(t2, counter, t1->get_num_args(), res); } + void compiler::find_min_aggregates(const rule * r, ptr_vector& min_aggregates) { + unsigned ut_len = r->get_uninterpreted_tail_size(); + unsigned ft_len = r->get_tail_size(); // full tail + func_decl * aggregate; + for (unsigned tail_index = ut_len; tail_index < ft_len; ++tail_index) { + aggregate = r->get_tail(tail_index)->get_decl(); + if (dl_decl_plugin::is_aggregate(aggregate)) { + min_aggregates.push_back(aggregate); + } + } + } + + bool compiler::prepare_min_aggregate(const func_decl * decl, const ptr_vector& min_aggregates, + unsigned_vector & group_by_cols, unsigned & min_col) { + for (unsigned i = 0; i < min_aggregates.size(); ++i) { + if (dl_decl_plugin::min_func_decl(min_aggregates[i]) == decl) { + group_by_cols = dl_decl_plugin::group_by_cols(min_aggregates[i]); + min_col = dl_decl_plugin::min_col(min_aggregates[i]); + return true; + } + } + return false; + } + void compiler::compile_rule_evaluation_run(rule * r, reg_idx head_reg, const reg_idx * tail_regs, reg_idx delta_reg, bool use_widening, instruction_block & acc) { @@ -465,6 +495,12 @@ namespace datalog { // whether to dealloc the previous result bool dealloc = true; + // setup information for min aggregation + ptr_vector min_aggregates; + find_min_aggregates(r, min_aggregates); + unsigned_vector group_by_cols; + unsigned min_col; + if(pt_len == 2) { reg_idx t1_reg=tail_regs[0]; reg_idx t2_reg=tail_regs[1]; @@ -473,6 +509,14 @@ namespace datalog { SASSERT(m_reg_signatures[t1_reg].size()==a1->get_num_args()); SASSERT(m_reg_signatures[t2_reg].size()==a2->get_num_args()); + if (prepare_min_aggregate(a1->get_decl(), min_aggregates, group_by_cols, min_col)) { + make_min(t1_reg, single_res, group_by_cols, min_col, acc); + } + + if (prepare_min_aggregate(a2->get_decl(), min_aggregates, group_by_cols, min_col)) { + make_min(t2_reg, single_res, group_by_cols, min_col, acc); + } + variable_intersection a1a2(m_context.get_manager()); a1a2.populate(a1,a2); @@ -514,6 +558,10 @@ namespace datalog { single_res = tail_regs[0]; dealloc = false; + if (prepare_min_aggregate(a->get_decl(), min_aggregates, group_by_cols, min_col)) { + make_min(single_res, single_res, group_by_cols, min_col, acc); + } + SASSERT(m_reg_signatures[single_res].size() == a->get_num_args()); unsigned n=a->get_num_args(); @@ -597,7 +645,8 @@ namespace datalog { unsigned ft_len = r->get_tail_size(); // full tail ptr_vector tail; for (unsigned tail_index = ut_len; tail_index < ft_len; ++tail_index) { - tail.push_back(r->get_tail(tail_index)); + if (!r->is_min_tail(tail_index)) + tail.push_back(r->get_tail(tail_index)); } expr_ref_vector binding(m); diff --git a/src/muz/rel/dl_compiler.h b/src/muz/rel/dl_compiler.h index 4902b9387d0..a9e37a8a3c4 100644 --- a/src/muz/rel/dl_compiler.h +++ b/src/muz/rel/dl_compiler.h @@ -120,6 +120,22 @@ namespace datalog { instruction_observer m_instruction_observer; expr_free_vars m_free_vars; + /** + \brief Finds all the min aggregation functions in the premise of a given rule. + */ + static void find_min_aggregates(const rule * r, ptr_vector& min_aggregates); + + /** + \brief Decides whether a predicate is subject to a min aggregation function. + + If \c decl is subject to a min aggregation function, the output parameters are written + with the neccessary information. + + \returns true if the output paramaters have been written + */ + static bool prepare_min_aggregate(const func_decl * decl, const ptr_vector& min_aggregates, + unsigned_vector & group_by_cols, unsigned & min_col); + /** If true, the union operation on the underlying structure only provides the information whether the updated relation has changed or not. In this case we do not get anything @@ -146,6 +162,8 @@ namespace datalog { void make_join(reg_idx t1, reg_idx t2, const variable_intersection & vars, reg_idx & result, bool reuse_t1, instruction_block & acc); + void make_min(reg_idx source, reg_idx & target, const unsigned_vector & group_by_cols, + const unsigned min_col, instruction_block & acc); void make_join_project(reg_idx t1, reg_idx t2, const variable_intersection & vars, const unsigned_vector & removed_cols, reg_idx & result, bool reuse_t1, instruction_block & acc); void make_filter_interpreted_and_project(reg_idx src, app_ref & cond, diff --git a/src/muz/rel/dl_instruction.cpp b/src/muz/rel/dl_instruction.cpp index 7eb8d4375f5..f8145b92283 100644 --- a/src/muz/rel/dl_instruction.cpp +++ b/src/muz/rel/dl_instruction.cpp @@ -25,6 +25,7 @@ Revision History: #include"rel_context.h" #include"debug.h" #include"warning.h" +#include"dl_table_relation.h" namespace datalog { @@ -552,7 +553,7 @@ namespace datalog { if (r.fast_empty()) { ctx.make_empty(m_reg); } - TRACE("dl_verbose", r.display(tout <<"post-filter-interpreted:\n");); + //TRACE("dl_verbose", r.display(tout <<"post-filter-interpreted:\n");); return true; } @@ -609,7 +610,7 @@ namespace datalog { if (ctx.reg(m_res)->fast_empty()) { ctx.make_empty(m_res); } - TRACE("dl_verbose", reg.display(tout << "post-filter-interpreted-and-project:\n");); + //TRACE("dl_verbose", reg.display(tout << "post-filter-interpreted-and-project:\n");); return true; } @@ -883,6 +884,59 @@ namespace datalog { removed_cols, result); } + class instr_min : public instruction { + reg_idx m_source_reg; + reg_idx m_target_reg; + unsigned_vector m_group_by_cols; + unsigned m_min_col; + public: + instr_min(reg_idx source_reg, reg_idx target_reg, const unsigned_vector & group_by_cols, unsigned min_col) + : m_source_reg(source_reg), + m_target_reg(target_reg), + m_group_by_cols(group_by_cols), + m_min_col(min_col) { + } + virtual bool perform(execution_context & ctx) { + log_verbose(ctx); + if (!ctx.reg(m_source_reg)) { + ctx.make_empty(m_target_reg); + return true; + } + + const relation_base & s = *ctx.reg(m_source_reg); + if (!s.from_table()) { + throw default_exception("relation is not a table %s", + s.get_plugin().get_name().bare_str()); + } + ++ctx.m_stats.m_min; + const table_relation & tr = static_cast(s); + const table_base & source_t = tr.get_table(); + relation_manager & r_manager = s.get_manager(); + + const relation_signature & r_sig = s.get_signature(); + scoped_ptr fn = r_manager.mk_min_fn(source_t, m_group_by_cols, m_min_col); + table_base * target_t = (*fn)(source_t); + + TRACE("dl", + tout << "% "; + target_t->display(tout); + tout << "\n";); + + relation_base * target_r = r_manager.mk_table_relation(r_sig, target_t); + ctx.set_reg(m_target_reg, target_r); + return true; + } + virtual void display_head_impl(execution_context const& ctx, std::ostream & out) const { + out << " MIN AGGR "; + } + virtual void make_annotations(execution_context & ctx) { + } + }; + + instruction * instruction::mk_min(reg_idx source, reg_idx target, const unsigned_vector & group_by_cols, + const unsigned min_col) { + return alloc(instr_min, source, target, group_by_cols, min_col); + } class instr_select_equal_and_project : public instruction { reg_idx m_src; diff --git a/src/muz/rel/dl_instruction.h b/src/muz/rel/dl_instruction.h index 3910f6d0b24..a02346b9972 100644 --- a/src/muz/rel/dl_instruction.h +++ b/src/muz/rel/dl_instruction.h @@ -93,6 +93,7 @@ namespace datalog { unsigned m_filter_interp_project; unsigned m_filter_id; unsigned m_filter_eq; + unsigned m_min; stats() { reset(); } void reset() { memset(this, 0, sizeof(*this)); } }; @@ -284,6 +285,8 @@ namespace datalog { static instruction * mk_join_project(reg_idx rel1, reg_idx rel2, unsigned joined_col_cnt, const unsigned * cols1, const unsigned * cols2, unsigned removed_col_cnt, const unsigned * removed_cols, reg_idx result); + static instruction * mk_min(reg_idx source, reg_idx target, const unsigned_vector & group_by_cols, + const unsigned min_col); static instruction * mk_rename(reg_idx src, unsigned cycle_len, const unsigned * permutation_cycle, reg_idx tgt); static instruction * mk_filter_by_negation(reg_idx tgt, reg_idx neg_rel, unsigned col_cnt, diff --git a/src/muz/rel/dl_relation_manager.cpp b/src/muz/rel/dl_relation_manager.cpp index b92c9f7964c..2b78baf05b4 100644 --- a/src/muz/rel/dl_relation_manager.cpp +++ b/src/muz/rel/dl_relation_manager.cpp @@ -108,7 +108,7 @@ namespace datalog { void relation_manager::store_relation(func_decl * pred, relation_base * rel) { SASSERT(rel); - relation_map::entry * e = m_relations.insert_if_not_there2(pred, 0); + relation_map::obj_map_entry * e = m_relations.insert_if_not_there2(pred, 0); if (e->get_data().m_value) { e->get_data().m_value->deallocate(); } @@ -354,7 +354,9 @@ namespace datalog { return product_relation_plugin::get_plugin(*this).mk_empty(s); } - + /** + The newly created object takes ownership of the \c table object. + */ relation_base * relation_manager::mk_table_relation(const relation_signature & s, table_base * table) { SASSERT(s.size()==table->get_signature().size()); return get_table_relation_plugin(table->get_plugin()).mk_from_table(s, table); @@ -1021,6 +1023,11 @@ namespace datalog { return res; } + table_min_fn * relation_manager::mk_min_fn(const table_base & t, + unsigned_vector & group_by_cols, const unsigned col) + { + return t.get_plugin().mk_min_fn(t, group_by_cols, col); + } class relation_manager::auxiliary_table_transformer_fn { table_fact m_row; diff --git a/src/muz/rel/dl_relation_manager.h b/src/muz/rel/dl_relation_manager.h index 530538df543..f91b7496a7d 100644 --- a/src/muz/rel/dl_relation_manager.h +++ b/src/muz/rel/dl_relation_manager.h @@ -73,7 +73,7 @@ namespace datalog { typedef map, ptr_eq > rp2fprp_map; - typedef map, ptr_eq > relation_map; + typedef obj_map relation_map; typedef ptr_vector table_plugin_vector; typedef ptr_vector relation_plugin_vector; @@ -251,6 +251,9 @@ namespace datalog { return mk_join_fn(t1, t2, cols1.size(), cols1.c_ptr(), cols2.c_ptr(), allow_product_relation); } + table_min_fn * mk_min_fn(const table_base & t, + unsigned_vector & group_by_cols, const unsigned col); + /** \brief Return functor that transforms a table into one that lacks columns listed in \c removed_cols array. diff --git a/src/muz/rel/dl_table_relation.cpp b/src/muz/rel/dl_table_relation.cpp index 364c29367e0..d42d071aaaf 100644 --- a/src/muz/rel/dl_table_relation.cpp +++ b/src/muz/rel/dl_table_relation.cpp @@ -63,6 +63,9 @@ namespace datalog { return alloc(table_relation, *this, s, t); } + /** + The newly created object takes ownership of the \c t object. + */ relation_base * table_relation_plugin::mk_from_table(const relation_signature & s, table_base * t) { if (&t->get_plugin() == &m_table_plugin) return alloc(table_relation, *this, s, t); diff --git a/src/muz/rel/karr_relation.cpp b/src/muz/rel/karr_relation.cpp index 436cd85984d..6b912616180 100644 --- a/src/muz/rel/karr_relation.cpp +++ b/src/muz/rel/karr_relation.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "karr_relation.h" #include "bool_rewriter.h" diff --git a/src/muz/rel/rel_context.cpp b/src/muz/rel/rel_context.cpp index c3ffdceaec9..d2a2f018160 100644 --- a/src/muz/rel/rel_context.cpp +++ b/src/muz/rel/rel_context.cpp @@ -290,19 +290,27 @@ namespace datalog { return res; } +#define _MIN_DONE_ 1 + void rel_context::transform_rules() { rule_transformer transf(m_context); +#ifdef _MIN_DONE_ transf.register_plugin(alloc(mk_coi_filter, m_context)); +#endif transf.register_plugin(alloc(mk_filter_rules, m_context)); transf.register_plugin(alloc(mk_simple_joins, m_context)); if (m_context.unbound_compressor()) { transf.register_plugin(alloc(mk_unbound_compressor, m_context)); } +#ifdef _MIN_DONE_ if (m_context.similarity_compressor()) { transf.register_plugin(alloc(mk_similarity_compressor, m_context)); } +#endif transf.register_plugin(alloc(mk_partial_equivalence_transformer, m_context)); +#ifdef _MIN_DONE_ transf.register_plugin(alloc(mk_rule_inliner, m_context)); +#endif transf.register_plugin(alloc(mk_interp_tail_simplifier, m_context)); transf.register_plugin(alloc(mk_separate_negated_tails, m_context)); diff --git a/src/muz/rel/udoc_relation.cpp b/src/muz/rel/udoc_relation.cpp index 6d69550eff1..587c5bfe123 100644 --- a/src/muz/rel/udoc_relation.cpp +++ b/src/muz/rel/udoc_relation.cpp @@ -1065,7 +1065,7 @@ namespace datalog { t1.get_signature().size() == joined_col_cnt && t2.get_signature().size() == joined_col_cnt) { for (unsigned i = 0; i < removed_col_cnt; ++i) { - if (removed_cols[i] != i) + if (removed_cols[i] != i || cols1[i] != cols2[i]) goto general_fn; } return alloc(join_project_and_fn); diff --git a/src/opt/opt_context.cpp b/src/opt/opt_context.cpp index bf8a9dd7fcc..6fb4ef54224 100644 --- a/src/opt/opt_context.cpp +++ b/src/opt/opt_context.cpp @@ -31,6 +31,7 @@ Module Name: #include "propagate_values_tactic.h" #include "solve_eqs_tactic.h" #include "elim_uncnstr_tactic.h" +#include "elim_term_ite_tactic.h" #include "tactical.h" #include "model_smt2_pp.h" #include "card2bv_tactic.h" @@ -650,17 +651,19 @@ namespace opt { and_then(mk_simplify_tactic(m), mk_propagate_values_tactic(m), mk_solve_eqs_tactic(m), + mk_elim_term_ite_tactic(m), // NB: mk_elim_uncstr_tactic(m) is not sound with soft constraints mk_simplify_tactic(m)); opt_params optp(m_params); - tactic_ref tac2, tac3; + tactic_ref tac2, tac3, tac4; if (optp.elim_01()) { tac2 = mk_elim01_tactic(m); tac3 = mk_lia2card_tactic(m); + tac4 = mk_elim_term_ite_tactic(m); params_ref lia_p; lia_p.set_bool("compile_equality", optp.pb_compile_equality()); tac3->updt_params(lia_p); - set_simplify(and_then(tac0.get(), tac2.get(), tac3.get())); + set_simplify(and_then(tac0.get(), tac2.get(), tac3.get(), tac4.get())); } else { set_simplify(tac0.get()); diff --git a/src/opt/opt_solver.cpp b/src/opt/opt_solver.cpp index d505a9ffb2b..dcbbc3faed1 100644 --- a/src/opt/opt_solver.cpp +++ b/src/opt/opt_solver.cpp @@ -42,7 +42,7 @@ namespace opt { m_context(mgr, m_params), m(mgr), m_fm(fm), - m_objective_sorts(m), + m_objective_terms(m), m_dump_benchmarks(false), m_first(true) { m_params.updt_params(p); @@ -213,11 +213,13 @@ namespace opt { } else { SASSERT(has_shared); - decrement_value(i, val); + decrement_value(i, val); } m_objective_values[i] = val; - TRACE("opt", { tout << val << "\n"; - tout << blocker << "\n"; + TRACE("opt", { + tout << "objective: " << mk_pp(m_objective_terms[i].get(), m) << "\n"; + tout << "maximal value: " << val << "\n"; + tout << "new condition: " << blocker << "\n"; model_smt2_pp(tout << "update model:\n", m, *m_models[i], 0); }); } @@ -240,7 +242,7 @@ namespace opt { TRACE("opt", tout << is_sat << "\n";); if (is_sat != l_true) { // cop-out approximation - if (arith_util(m).is_real(m_objective_sorts[i].get())) { + if (arith_util(m).is_real(m_objective_terms[i].get())) { val -= inf_eps(inf_rational(rational(0), true)); } else { @@ -304,7 +306,7 @@ namespace opt { smt::theory_var v = get_optimizer().add_objective(term); m_objective_vars.push_back(v); m_objective_values.push_back(inf_eps(rational(-1), inf_rational())); - m_objective_sorts.push_back(m.get_sort(term)); + m_objective_terms.push_back(term); m_valid_objectives.push_back(true); m_models.push_back(0); return v; @@ -363,7 +365,7 @@ namespace opt { void opt_solver::reset_objectives() { m_objective_vars.reset(); m_objective_values.reset(); - m_objective_sorts.reset(); + m_objective_terms.reset(); m_valid_objectives.reset(); } diff --git a/src/opt/opt_solver.h b/src/opt/opt_solver.h index 19205ddd9ed..a18ad954007 100644 --- a/src/opt/opt_solver.h +++ b/src/opt/opt_solver.h @@ -76,7 +76,7 @@ namespace opt { svector m_objective_vars; vector m_objective_values; sref_vector m_models; - sort_ref_vector m_objective_sorts; + expr_ref_vector m_objective_terms; svector m_valid_objectives; bool m_dump_benchmarks; static unsigned m_dump_count; diff --git a/src/opt/optsmt.cpp b/src/opt/optsmt.cpp index 6b061f9cd3e..02effa337a8 100644 --- a/src/opt/optsmt.cpp +++ b/src/opt/optsmt.cpp @@ -141,6 +141,7 @@ namespace opt { ors.push_back(m_s->mk_ge(i, m_upper[i])); } + fml = m.mk_or(ors.size(), ors.c_ptr()); tmp = m.mk_fresh_const("b", m.mk_bool_sort()); fml = m.mk_implies(tmp, fml); @@ -150,6 +151,7 @@ namespace opt { solver::scoped_push _push(*m_s); while (!m_cancel) { m_s->assert_expr(fml); + TRACE("opt", tout << fml << "\n";); is_sat = m_s->check_sat(1,vars); if (is_sat == l_true) { disj.reset(); @@ -343,6 +345,7 @@ namespace opt { m_lower[i] = m_s->saved_objective_value(i); } } + TRACE("opt", tout << "strengthen bound: " << block << "\n";); m_s->assert_expr(block); // TBD: only works for simplex diff --git a/src/parsers/smt/smtlib.cpp b/src/parsers/smt/smtlib.cpp index d53d3cafa45..b743b5b0fb3 100644 --- a/src/parsers/smt/smtlib.cpp +++ b/src/parsers/smt/smtlib.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include"smtlib.h" #include"ast_pp.h" #include"ast_smt2_pp.h" diff --git a/src/qe/nlarith_util.cpp b/src/qe/nlarith_util.cpp index c555b71f178..b7c1aef5dcc 100644 --- a/src/qe/nlarith_util.cpp +++ b/src/qe/nlarith_util.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "ast.h" #include "nlarith_util.h" #include "arith_decl_plugin.h" diff --git a/src/qe/qe_arith.h b/src/qe/qe_arith.h index c8f7e8b8d0e..725245fada2 100644 --- a/src/qe/qe_arith.h +++ b/src/qe/qe_arith.h @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #ifndef __QE_ARITH_H_ #define __QE_ARITH_H_ diff --git a/src/qe/qe_array_plugin.cpp b/src/qe/qe_array_plugin.cpp index c9de1d74519..e7cbe65b9fb 100644 --- a/src/qe/qe_array_plugin.cpp +++ b/src/qe/qe_array_plugin.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include "qe.h" #include "array_decl_plugin.h" #include "expr_safe_replace.h" diff --git a/src/qe/qe_cmd.cpp b/src/qe/qe_cmd.cpp index 6f001c9da91..9144c708c5d 100644 --- a/src/qe/qe_cmd.cpp +++ b/src/qe/qe_cmd.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "qe_cmd.h" #include "qe.h" #include "cmd_context.h" diff --git a/src/qe/qe_datatype_plugin.cpp b/src/qe/qe_datatype_plugin.cpp index 9b77de42a5c..088d2252db5 100644 --- a/src/qe/qe_datatype_plugin.cpp +++ b/src/qe/qe_datatype_plugin.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + // --------------------- // datatypes // Quantifier elimination routine for recursive data-types. diff --git a/src/qe/qe_dl_plugin.cpp b/src/qe/qe_dl_plugin.cpp index a93301b4fd1..e04f4cbdec0 100644 --- a/src/qe/qe_dl_plugin.cpp +++ b/src/qe/qe_dl_plugin.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include "qe.h" #include "expr_safe_replace.h" #include "dl_decl_plugin.h" diff --git a/src/qe/qe_mbp.h b/src/qe/qe_mbp.h deleted file mode 100644 index 11bceef0b46..00000000000 --- a/src/qe/qe_mbp.h +++ /dev/null @@ -1,48 +0,0 @@ -/*++ -Copyright (c) 2015 Microsoft Corporation - -Module Name: - - qe_mbp.h - -Abstract: - - Model-based projection utilities - -Author: - - Nikolaj Bjorner (nbjorner) 2015-5-28 - -Revision History: - - ---*/ - -#ifndef __QE_MBP_H__ -#define __QE_MBP_H__ - -#include "ast.h" -#include "params.h" - -namespace qe { - class mbp { - class impl; - impl * m_impl; - public: - mbp(ast_manager& m); - - ~mbp(); - - /** - \brief - Apply model-based qe on constants provided as vector of variables. - Return the updated formula and updated set of variables that were not eliminated. - - */ - void operator()(app_ref_vector& vars, model_ref& mdl, expr_ref& fml); - - void set_cancel(bool f); - }; -} - -#endif diff --git a/src/qe/qe_util.cpp b/src/qe/qe_util.cpp index 77396ac499c..2cf723c0838 100644 --- a/src/qe/qe_util.cpp +++ b/src/qe/qe_util.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "qe_util.h" #include "bool_rewriter.h" diff --git a/src/qe/qsat.cpp b/src/qe/qsat.cpp deleted file mode 100644 index 4c736bc31b3..00000000000 --- a/src/qe/qsat.cpp +++ /dev/null @@ -1,281 +0,0 @@ -/*++ -Copyright (c) 2015 Microsoft Corporation - -Module Name: - - qsat.cpp - -Abstract: - - Quantifier Satisfiability Solver. - -Author: - - Nikolaj Bjorner (nbjorner) 2015-5-28 - -Revision History: - - ---*/ - -#include "qsat.h" -#include "smt_kernel.h" -#include "qe_mbp.h" -#include "smt_params.h" -#include "ast_util.h" - -using namespace qe; - -struct qdef_t { - expr_ref m_pred; - expr_ref m_expr; - expr_ref_vector m_vars; - bool m_is_forall; - qdef_t(expr_ref& p, expr_ref& e, expr_ref_vector const& vars, bool is_forall): - m_pred(p), - m_expr(e), - m_vars(vars), - m_is_forall(is_forall) {} -}; - -typedef vector qdefs_t; - -struct pdef_t { - expr_ref m_pred; - expr_ref m_atom; - pdef_t(expr_ref& p, expr* a): - m_pred(p), - m_atom(a, p.get_manager()) - {} -}; - -class qsat::impl { - ast_manager& m; - qe::mbp mbp; - smt_params m_smtp; - smt::kernel m_kernel; - expr_ref m_fml_pred; // predicate that encodes top-level formula - expr_ref_vector m_atoms; // predicates that encode atomic subformulas - - - lbool check_sat() { - // TBD main procedure goes here. - return l_undef; - } - - /** - \brief replace quantified sub-formulas by a predicate, introduce definitions for the predicate. - */ - void remove_quantifiers(expr_ref_vector& fmls, qdefs_t& defs) { - - } - - /** - \brief create propositional abstration of formula by replacing atomic sub-formulas by fresh - propositional variables, and adding definitions for each propositional formula on the side. - Assumption is that the formula is quantifier-free. - */ - void mk_abstract(expr_ref& fml, vector& pdefs) { - expr_ref_vector todo(m), trail(m); - obj_map cache; - ptr_vector args; - expr_ref r(m); - todo.push_back(fml); - while (!todo.empty()) { - expr* e = todo.back(); - if (cache.contains(e)) { - todo.pop_back(); - continue; - } - SASSERT(is_app(e)); - app* a = to_app(e); - if (a->get_family_id() == m.get_basic_family_id()) { - unsigned sz = a->get_num_args(); - args.reset(); - for (unsigned i = 0; i < sz; ++i) { - expr* f = a->get_arg(i); - if (cache.find(f, f)) { - args.push_back(f); - } - else { - todo.push_back(f); - } - } - if (args.size() == sz) { - r = m.mk_app(a->get_decl(), sz, args.c_ptr()); - cache.insert(e, r); - trail.push_back(r); - todo.pop_back(); - } - } - else if (is_uninterp_const(a)) { - cache.insert(e, e); - } - else { - // TBD: nested Booleans. - - r = m.mk_fresh_const("p",m.mk_bool_sort()); - trail.push_back(r); - cache.insert(e, r); - pdefs.push_back(pdef_t(r, e)); - } - } - fml = cache.find(fml); - } - - /** - \brief use dual propagation to minimize model. - */ - bool minimize_assignment(expr_ref_vector& assignment, expr* not_fml) { - bool result = false; - assignment.push_back(not_fml); - lbool res = m_kernel.check(assignment.size(), assignment.c_ptr()); - switch (res) { - case l_true: - UNREACHABLE(); - break; - case l_undef: - break; - case l_false: - result = true; - get_core(assignment, not_fml); - break; - } - return result; - } - - lbool check_sat(expr_ref_vector& assignment, expr* fml) { - assignment.push_back(fml); - lbool res = m_kernel.check(assignment.size(), assignment.c_ptr()); - switch (res) { - case l_true: { - model_ref mdl; - expr_ref tmp(m); - assignment.reset(); - m_kernel.get_model(mdl); - for (unsigned i = 0; i < m_atoms.size(); ++i) { - expr* p = m_atoms[i].get(); - if (mdl->eval(p, tmp)) { - if (m.is_true(tmp)) { - assignment.push_back(p); - } - else if (m.is_false(tmp)) { - assignment.push_back(m.mk_not(p)); - } - } - } - expr_ref not_fml = mk_not(fml); - if (!minimize_assignment(assignment, not_fml)) { - res = l_undef; - } - break; - } - case l_undef: - break; - case l_false: - get_core(assignment, fml); - break; - } - return res; - } - - void get_core(expr_ref_vector& core, expr* exclude) { - unsigned sz = m_kernel.get_unsat_core_size(); - core.reset(); - for (unsigned i = 0; i < sz; ++i) { - expr* e = m_kernel.get_unsat_core_expr(i); - if (e != exclude) { - core.push_back(e); - } - } - } - - expr_ref mk_not(expr* e) { - return expr_ref(::mk_not(m, e), m); - } - -public: - impl(ast_manager& m): - m(m), - mbp(m), - m_kernel(m, m_smtp), - m_fml_pred(m), - m_atoms(m) {} - - void updt_params(params_ref const & p) { - } - - void collect_param_descrs(param_descrs & r) { - } - - void operator()(/* in */ goal_ref const & in, - /* out */ goal_ref_buffer & result, - /* out */ model_converter_ref & mc, - /* out */ proof_converter_ref & pc, - /* out */ expr_dependency_ref & core) { - - } - - void collect_statistics(statistics & st) const { - - } - void reset_statistics() { - } - - void cleanup() { - } - - void set_logic(symbol const & l) { - } - - void set_progress_callback(progress_callback * callback) { - } - - tactic * translate(ast_manager & m) { - return 0; - } - -}; - -qsat::qsat(ast_manager& m) { - m_impl = alloc(impl, m); -} - -qsat::~qsat() { - dealloc(m_impl); -} - -void qsat::updt_params(params_ref const & p) { - m_impl->updt_params(p); -} -void qsat::collect_param_descrs(param_descrs & r) { - m_impl->collect_param_descrs(r); -} -void qsat::operator()(/* in */ goal_ref const & in, - /* out */ goal_ref_buffer & result, - /* out */ model_converter_ref & mc, - /* out */ proof_converter_ref & pc, - /* out */ expr_dependency_ref & core) { - (*m_impl)(in, result, mc, pc, core); -} - -void qsat::collect_statistics(statistics & st) const { - m_impl->collect_statistics(st); -} -void qsat::reset_statistics() { - m_impl->reset_statistics(); -} -void qsat::cleanup() { - m_impl->cleanup(); -} -void qsat::set_logic(symbol const & l) { - m_impl->set_logic(l); -} -void qsat::set_progress_callback(progress_callback * callback) { - m_impl->set_progress_callback(callback); -} -tactic * qsat::translate(ast_manager & m) { - return m_impl->translate(m); -} - - diff --git a/src/qe/qsat.h b/src/qe/qsat.h deleted file mode 100644 index 2fc071c76b1..00000000000 --- a/src/qe/qsat.h +++ /dev/null @@ -1,52 +0,0 @@ -/*++ -Copyright (c) 2015 Microsoft Corporation - -Module Name: - - qsat.h - -Abstract: - - Quantifier Satisfiability Solver. - -Author: - - Nikolaj Bjorner (nbjorner) 2015-5-28 - -Revision History: - - ---*/ - -#ifndef __QE_QSAT_H__ -#define __QE_QSAT_H__ - -#include "tactic.h" - -namespace qe { - class qsat : public tactic { - class impl; - impl * m_impl; - public: - qsat(ast_manager& m); - ~qsat(); - - virtual void updt_params(params_ref const & p); - virtual void collect_param_descrs(param_descrs & r); - virtual void operator()(/* in */ goal_ref const & in, - /* out */ goal_ref_buffer & result, - /* out */ model_converter_ref & mc, - /* out */ proof_converter_ref & pc, - /* out */ expr_dependency_ref & core); - - virtual void collect_statistics(statistics & st) const; - virtual void reset_statistics(); - virtual void cleanup() = 0; - virtual void set_logic(symbol const & l); - virtual void set_progress_callback(progress_callback * callback); - virtual tactic * translate(ast_manager & m); - - }; -}; - -#endif diff --git a/src/sat/sat_solver.h b/src/sat/sat_solver.h index 357b79f4969..e3628823fc0 100644 --- a/src/sat/sat_solver.h +++ b/src/sat/sat_solver.h @@ -210,6 +210,7 @@ namespace sat { public: bool inconsistent() const { return m_inconsistent; } unsigned num_vars() const { return m_level.size(); } + unsigned num_clauses() const; bool is_external(bool_var v) const { return m_external[v] != 0; } bool was_eliminated(bool_var v) const { return m_eliminated[v] != 0; } unsigned scope_lvl() const { return m_scope_lvl; } @@ -447,7 +448,6 @@ namespace sat { protected: void display_binary(std::ostream & out) const; void display_units(std::ostream & out) const; - unsigned num_clauses() const; bool is_unit(clause const & c) const; bool is_empty(clause const & c) const; bool check_missed_propagation(clause_vector const & cs) const; diff --git a/src/shell/main.cpp b/src/shell/main.cpp index 5a47d0d1693..609f5d47bfb 100644 --- a/src/shell/main.cpp +++ b/src/shell/main.cpp @@ -163,6 +163,9 @@ void parse_cmd_line_args(int argc, char ** argv) { else if (strcmp(opt_name, "smt2") == 0) { g_input_kind = IN_SMTLIB_2; } + else if (strcmp(opt_name, "dl") == 0) { + g_input_kind = IN_DATALOG; + } else if (strcmp(opt_name, "in") == 0) { g_standard_input = true; } diff --git a/src/shell/opt_frontend.cpp b/src/shell/opt_frontend.cpp index 6e39313fd0f..78d083e6edc 100644 --- a/src/shell/opt_frontend.cpp +++ b/src/shell/opt_frontend.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include #include diff --git a/src/shell/options.h b/src/shell/options.h index 951062ff091..ee1de00fb99 100644 --- a/src/shell/options.h +++ b/src/shell/options.h @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + /** \page cmdline Command line options diff --git a/src/smt/database.h b/src/smt/database.h index 69843f43488..3edb87f1f56 100644 --- a/src/smt/database.h +++ b/src/smt/database.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + static char const g_pattern_database[] = "(benchmark patterns \n" " :status unknown \n" diff --git a/src/smt/theory_arith.h b/src/smt/theory_arith.h index db4b0139535..6531c33f241 100644 --- a/src/smt/theory_arith.h +++ b/src/smt/theory_arith.h @@ -885,6 +885,7 @@ namespace smt { void add_tmp_row_entry(row & r, numeral const & coeff, theory_var v); enum max_min_t { UNBOUNDED, AT_BOUND, OPTIMIZED, BEST_EFFORT}; max_min_t max_min(theory_var v, bool max, bool maintain_integrality, bool& has_shared); + bool has_interface_equality(theory_var v); bool max_min(svector const & vars); max_min_t max_min(row& r, bool max, bool maintain_integrality, bool& has_shared); diff --git a/src/smt/theory_arith_aux.h b/src/smt/theory_arith_aux.h index 91ee6def5b7..8bf36668293 100644 --- a/src/smt/theory_arith_aux.h +++ b/src/smt/theory_arith_aux.h @@ -1545,6 +1545,25 @@ namespace smt { return is_tighter; } + /** + \brief Check if bound change affects interface equality. + */ + template + bool theory_arith::has_interface_equality(theory_var x) { + theory_var num = get_num_vars(); + context& ctx = get_context(); + enode* r = get_enode(x)->get_root(); + for (theory_var v = 0; v < num; v++) { + if (v == x) continue; + enode* n = get_enode(v); + if (ctx.is_shared(n) && n->get_root() == r) { + return true; + } + } + return false; + } + + /** \brief Maximize (Minimize) the given temporary row. Return true if succeeded. @@ -1660,13 +1679,23 @@ namespace smt { SASSERT(!maintain_integrality || valid_assignment()); continue; } - if (ctx.is_shared(get_enode(x_j))) { +#if 0 + if (ctx.is_shared(get_enode(x_j)) && has_interface_equality(x_j)) { ++best_efforts; } else { SASSERT(unbounded_gain(max_gain)); + has_shared = false; best_efforts = 0; } +#endif + // + // NB. As it stands this is a possibly unsound conclusion for shared theories. + // the tradeoff is non-termination for unbounded objectives in the + // presence of sharing. + // + has_shared = false; + best_efforts = 0; result = UNBOUNDED; break; } diff --git a/src/smt/theory_array_full.cpp b/src/smt/theory_array_full.cpp index f2d1527c0aa..4e169a8beea 100644 --- a/src/smt/theory_array_full.cpp +++ b/src/smt/theory_array_full.cpp @@ -785,7 +785,10 @@ namespace smt { else { m_eqs.insert(v1, v2, true); literal eq(mk_eq(v1, v2, true)); - m_eqsv.push_back(eq); + get_context().mark_as_relevant(eq); + assert_axiom(eq); + + // m_eqsv.push_back(eq); return true; } } diff --git a/src/tactic/arith/arith_bounds_tactic.cpp b/src/tactic/arith/arith_bounds_tactic.cpp index dc24a625bfb..83b5c6daf31 100644 --- a/src/tactic/arith/arith_bounds_tactic.cpp +++ b/src/tactic/arith/arith_bounds_tactic.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include"arith_bounds_tactic.h" #include"arith_decl_plugin.h" diff --git a/src/tactic/arith/card2bv_tactic.cpp b/src/tactic/arith/card2bv_tactic.cpp index 933b687b4d6..4651731960f 100644 --- a/src/tactic/arith/card2bv_tactic.cpp +++ b/src/tactic/arith/card2bv_tactic.cpp @@ -485,10 +485,9 @@ class card2bv_tactic : public tactic { return; } - unsigned size = g->size(); expr_ref new_f1(m), new_f2(m); proof_ref new_pr1(m), new_pr2(m); - for (unsigned idx = 0; idx < size; idx++) { + for (unsigned idx = 0; !g->inconsistent() && idx < g->size(); idx++) { m_rw1(g->form(idx), new_f1, new_pr1); TRACE("card2bv", tout << "Rewriting " << mk_ismt2_pp(new_f1.get(), m) << std::endl;); m_rw2.rewrite(new_f1, new_f2); diff --git a/src/tactic/arith/pb2bv_tactic.cpp b/src/tactic/arith/pb2bv_tactic.cpp index 643195b0549..1ef0efc472f 100644 --- a/src/tactic/arith/pb2bv_tactic.cpp +++ b/src/tactic/arith/pb2bv_tactic.cpp @@ -854,7 +854,7 @@ class pb2bv_tactic : public tactic { m_temporary_ints(m), m_used_dependencies(m), m_rw(*this) { - updt_params(p); + updt_params(p); m_b_rw.set_flat(false); // no flattening otherwise will blowup the memory m_b_rw.set_elim_and(true); } @@ -871,12 +871,17 @@ class pb2bv_tactic : public tactic { m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); m_all_clauses_limit = p.get_uint("pb2bv_all_clauses_limit", 8); m_cardinality_limit = p.get_uint("pb2bv_cardinality_limit", UINT_MAX); + m_b_rw.updt_params(p); } void collect_param_descrs(param_descrs & r) { - insert_max_memory(r); + insert_max_memory(r); r.insert("pb2bv_all_clauses_limit", CPK_UINT, "(default: 8) maximum number of literals for using equivalent CNF encoding of PB constraint."); r.insert("pb2bv_cardinality_limit", CPK_UINT, "(default: inf) limit for using arc-consistent cardinality constraint encoding."); + + m_b_rw.get_param_descrs(r); + r.erase("flat"); + r.erase("elim_and"); } void set_cancel(bool f) { diff --git a/src/tactic/fpa/const_intro_rewriter.h b/src/tactic/fpa/const_intro_rewriter.h new file mode 100644 index 00000000000..5c4675fbb2b --- /dev/null +++ b/src/tactic/fpa/const_intro_rewriter.h @@ -0,0 +1,150 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + const_intro_rewriter.h + +Abstract: + + Rewriter for converting FPA to BV + +Author: + + Christoph (cwinter) 2012-02-09 + +Notes: + +--*/ + +#ifndef _CONST_INTRO_REWRITER_H_ +#define _CONST_INTRO_REWRITER_H_ + +#include"cooperate.h" +#include"bv_decl_plugin.h" +#include"tactic_exception.h" +#include"fpa2bv_converter_prec.h" + +struct const_intro_rewriter_cfg : public default_rewriter_cfg { + ast_manager & m_manager; + + expr * m_exp; + func_decl_ref_vector m_introduced_consts; + obj_map m_const2term_map; + + unsigned long long m_max_memory; + unsigned m_max_steps; + + fpa_util m_float_util; + + ast_manager & m() const { return m_manager; } + + const_intro_rewriter_cfg(ast_manager & m, params_ref const & p): + m_manager(m), + m_introduced_consts(m), + m_float_util(m) { + updt_params(p); + // We need to make sure that the mananger has the BV plugin loaded. + symbol s_bv("bv"); + if (!m_manager.has_plugin(s_bv)) + m_manager.register_plugin(s_bv, alloc(bv_decl_plugin)); + } + + ~const_intro_rewriter_cfg() { + for (obj_map::iterator it = m_const2term_map.begin(); + it != m_const2term_map.end(); + it++) + { + m().dec_ref(it->m_key); + m().dec_ref(it->m_value); + } + } + + void cleanup_buffers() { + } + + void updt_params(params_ref const & p) { + m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); + m_max_steps = p.get_uint("max_steps", UINT_MAX); + } + + bool max_steps_exceeded(unsigned num_steps) const { + cooperate("fpa2bv"); + if (memory::get_allocation_size() > m_max_memory) + throw tactic_exception(TACTIC_MAX_MEMORY_MSG); + return num_steps > m_max_steps; + } + + br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) { + TRACE("fpa2bv_rw", tout << "APP: " << f->get_name() << std::endl; ); + + if (num == 0 && f->get_family_id() == null_family_id && m_float_util.is_float(f->get_range())) { + app * f_cnst = m_manager.mk_const(f); + if (!m_introduced_consts.contains(f)) + m_introduced_consts.push_back(f); + result = f_cnst; + return BR_DONE; + } + + if (f->get_family_id() == m_float_util.get_family_id()) { + switch (f->get_decl_kind()) { + case OP_FPA_ADD: + case OP_FPA_SUB: + case OP_FPA_NEG: + case OP_FPA_MUL: + case OP_FPA_DIV: + case OP_FPA_REM: + case OP_FPA_ABS: + case OP_FPA_MIN: + case OP_FPA_MAX: + case OP_FPA_FMA: + case OP_FPA_SQRT: + case OP_FPA_TO_FP: + case OP_FPA_ROUND_TO_INTEGRAL: + { + app * f_app = m_manager.mk_app(f, num, args); + result = m_manager.mk_fresh_const(NULL, f->get_range()); + func_decl * fd = to_app(result)->get_decl(); + m_introduced_consts.push_back(fd); + m_const2term_map.insert_if_not_there(fd, f_app); + m().inc_ref(fd); + m().inc_ref(f_app); + return BR_DONE; + } + default: + return BR_FAILED; + } + } + + return BR_FAILED; + } + + bool reduce_quantifier(quantifier * old_q, + expr * new_body, + expr * const * new_patterns, + expr * const * new_no_patterns, + expr_ref & result, + proof_ref & result_pr) { + return false; + } + + bool reduce_var(var * t, expr_ref & result, proof_ref & result_pr) { + return false; + } + + bool pre_visit(expr * t){ + return true; + } +}; + +template class rewriter_tpl; + +struct const_intro_rewriter : public rewriter_tpl { + const_intro_rewriter_cfg m_cfg; + const_intro_rewriter(ast_manager & m, params_ref const & p): + rewriter_tpl(m, m.proofs_enabled(), m_cfg), + m_cfg(m, p) { + } +}; + +#endif diff --git a/src/tactic/fpa/fpa2bv_approx_tactic.cpp b/src/tactic/fpa/fpa2bv_approx_tactic.cpp new file mode 100644 index 00000000000..4d52a11ca87 --- /dev/null +++ b/src/tactic/fpa/fpa2bv_approx_tactic.cpp @@ -0,0 +1,1313 @@ +/*++ + Copyright (c) 2012 Microsoft Corporation + + Module Name: + + fpa2bv_approx_tactic.cpp + + Abstract: + + Tactic that converts floating points to bit-vectors lazily + + Author: + + Aleksander Zeljic 2012-11-15 + + Notes: + + --*/ +#include"tactical.h" +#include"cooperate.h" +#include"ref_util.h" + +#include"th_rewriter.h" +#include"bit_blaster_rewriter.h" +#include"bit_blaster_model_converter.h" +#include"model_v2_pp.h" +#include"goal2sat.h" +#include"sat_solver.h" +#include"fpa_decl_plugin.h" +#include"fpa2bv_converter_prec.h" +#include"fpa2bv_model_converter.h" +#include"fpa2bv_converter.h" +#include"propagate_values_tactic.h" +#include"fpa2bv_rewriter_prec.h" +#include"fpa2bv_approx_tactic.h" +#include"const_intro_rewriter.h" +#include"ctx_simplify_tactic.h" +#include"filter_model_converter.h" +#include +#include +#include + +#include + +#define K_MIN 10 +#define K_PERCENTAGE 0.3 +#define PREC_INCREMENT 20 +#define ERR_OP 0 // + +struct pair +{ + expr * exp; + double quotient;// mpf * +}; + +bool isinfinite(double x) { +#ifdef _WIN32 + int c = _fpclass(x); + return c == _FPCLASS_PINF || c == _FPCLASS_NINF; +#else + return fpclassify(x) == FP_INFINITE; +#endif +} + +class fpa2bv_approx_tactic: public tactic { + struct imp { + ast_manager & m; + goal2sat m_goal2sat; + sat2goal m_sat2goal; + params_ref m_params; + unsigned m_num_steps; + bool m_proofs_enabled; + bool m_produce_models; + bool m_produce_unsat_cores; + bool m_cancel; + + fpa_approximation_mode m_mode; + ast_manager * m_temp_manager; + model_ref m_fpa_model; + fpa_util m_float_util; + + imp(ast_manager & _m, params_ref const & p, fpa_approximation_mode mode) : + m(_m), + m_params(p), + m_proofs_enabled(false), + m_produce_models(false), + m_produce_unsat_cores(false), + m_cancel(false), + m_mode(mode), + m_temp_manager(0), + m_float_util(_m) { + } + + void updt_params(params_ref const & p) { + m_params = p; + } + + void set_cancel(bool f) { + //If f is true stop everything + m_cancel = f; + } + + void init_precision_mapping(func_decl_ref_vector const & cnsts, + obj_map & map, + obj_map & const2term_map) { + for (unsigned i = 0; i < cnsts.size(); i++) + { + if (const2term_map.contains(cnsts.get(i)) || m_mode == FPAA_SMALL_FLOATS) + map.insert_if_not_there(cnsts.get(i), 0); + else + map.insert_if_not_there(cnsts.get(i), MAX_PRECISION); + } + } + + bool proof_guided_refinement( + goal_ref const & g, + func_decl_ref_vector const & cnsts, + obj_map & cnst2prec_map, + obj_map & new_map) + { + // We have no model. Let's just increase precision of everything. + bool res = false; + for (unsigned i = 0; i < cnsts.size(); i++) + { + unsigned old = cnst2prec_map.find(cnsts.get(i)); + unsigned n = old + PREC_INCREMENT; + if (old >= MAX_PRECISION) n = MAX_PRECISION; + else { if (n > MAX_PRECISION) n = MAX_PRECISION; res = true; } + new_map.insert(cnsts.get(i), n); + } + return res; + } + + void boolean_comparison_of_models(goal_ref g, model_ref const & mdl, model_ref const & full_mdl, obj_map & cnst2term_map, obj_map& count) + { + std::queue to_traverse; + app * cur; + int cur_cnt; + + expr_ref mdl_eval(m), full_eval(m); + + for (unsigned i=0; i < g->size(); i++){ + mdl->eval(g->form(i),mdl_eval,true); + full_mdl->eval(g->form(i),full_eval,true); + + //Push only if the full model evaluates to false, or if the models differ? + if (!m.is_true(full_eval)) // m.is_true(full_eval) != m.is_true(mdl_eval) + to_traverse.push(g->form(i)); + } + + while (to_traverse.size() > 0) { + cur = to_app(to_traverse.front()); +#ifdef Z3DEBUG + std::cout<<"Analyze - traversing: "<get_decl())) + count.insert(cur,1); + + if(cnst2term_map.contains(cur->get_decl())) + to_traverse.push(cnst2term_map.find(cur->get_decl())); + + for(unsigned i=0;iget_num_args();i++) { + if(m_float_util.is_rm(cur->get_arg(i)) || m_float_util.is_numeral(cur->get_arg(i))) + continue; + to_traverse.push(cur->get_arg(i)); + } + } + else { //Comparing boolean values from the model and the expanded model + mdl->eval(cur,mdl_eval,true); + full_mdl->eval(cur,full_eval,true); + + + if (m.is_true(full_eval) != m.is_true(mdl_eval)) { + //queue arguments + for(unsigned i=0; i < cur->get_num_args(); i++) + to_traverse.push(cur->get_arg(i)); + } + } + to_traverse.pop(); + } +#ifdef Z3DEBUG + std::cout<<"Expression count"<::iterator it = count.begin(); + it!= count.end(); + it++) { + std::cout<m_key,m)<<":"<m_value<size();i++) { + eq = to_app(g->form(i)); + + if (eq->get_family_id() == m.get_basic_family_id() && + eq->get_decl_kind() == OP_EQ){ + //eq is in fact an equality + app * lhs = to_app(eq->get_arg(0)); + app * rhs = to_app(eq->get_arg(1)); + expr * lhs_e,*rhs_e,*exp, *exp_e; + app *other = NULL; + + + if(lhs->get_num_args()==0 && + rhs ->get_num_args()==0){ + //over constants + lhs_e = full_mdl->get_const_interp(lhs->get_decl()); + rhs_e = full_mdl->get_const_interp(rhs->get_decl()); + + // != would work as well, to make sure they are not both NULL, + //and could simplify later checks + if(lhs_e != rhs_e) { //SASSERT(lhs_e || rhs_e); + //and one is registered in the full model while the other is not + if(!lhs_e){// && rhs_e){ + other = lhs; + exp_e = rhs_e; + exp = rhs; + } + else { // if(!rhs_e && lhs_e){ + other = rhs; + exp_e = lhs_e; + exp = lhs; + } + full_mdl->register_decl(other->get_decl(),exp_e); + +#ifdef Z3DEBUG + std::cout< & cnst2term_map, + obj_map & precise_op, + obj_map & actual_value, + obj_map & err_est, + mpf_rounding_mode & rm, + bool & precise_children, + bool & seen_all_children, + bool & children_have_finite_err, + mpf * arg_val, + mpf * est_arg_val + //expr_ref * arg_e + ){ + + expr_ref arg_e[] = { expr_ref(m), expr_ref(m), expr_ref(m), expr_ref(m) }; + unsigned i=0; + //Set rounding mode + if (rhs->get_num_args() > 0 && m_float_util.is_rm(rhs->get_arg(0))) { + expr_ref rm_val(m); + mdl->eval(rhs->get_arg(0), rm_val, true); + m_float_util.is_rm_numeral(rm_val, rm); + i = 1; + } + //Collect argument values + for (; i < rhs->get_num_args(); i++) { + expr * arg = rhs->get_arg(i); + + if (is_app(arg) && to_app(arg)->get_num_args() == 0) { + if (precise_op.contains(arg)) { + precise_children &= precise_op.find(arg); + } + else if (!cnst2term_map.contains(to_app(arg)->get_decl())) { + /* that's okay */ + } + else { +#ifdef Z3DEBUG + std::cout << "Not seen all children of " << mk_ismt2_pp(rhs, m) << + " (spec. " << mk_ismt2_pp(arg, m) << ")" << std::endl; +#endif + precise_children = false; + seen_all_children = false; + break; + } + } + + // Value from small model + mdl->eval(arg, arg_e[i],true); + m_float_util.is_numeral(arg_e[i], arg_val[i]); + + if( children_have_finite_err && + err_est.contains(arg) && + isinfinite(err_est.find(arg))) + children_have_finite_err=false; + + if (actual_value.contains(arg)) + mpf_mngr.set(est_arg_val[i], *actual_value.find(arg)); + else if (seen_all_children && is_app(arg) && to_app(arg)->get_num_args()==0) { + //We have seen all children so if it is a constant and not in actual_value then + //it is an input variable and its est_val is the same as actual value + mpf * tmp = alloc(mpf); + mpf_mngr.set(*tmp, arg_val[i]); + actual_value.insert(arg, tmp); + mpf_mngr.set(est_arg_val[i], *tmp); + } + else + std::cout << "Estimated value missing: " << mk_ismt2_pp(arg,m) << std::endl; + } + + } + + + void full_semantics_eval( + app * rhs, + mpf_manager & mpf_mngr, + mpf_rounding_mode & rm, + mpf * arg_val, + mpf * est_arg_val, + mpf & rhs_value, + mpf & est_rhs_value){ + + switch (rhs->get_decl()->get_decl_kind()) { + case OP_FPA_ADD: + mpf_mngr.add(rm, arg_val[1], arg_val[2], rhs_value); + mpf_mngr.add(rm, est_arg_val[1], est_arg_val[2], est_rhs_value); + break; + case OP_FPA_SUB: + mpf_mngr.sub(rm, arg_val[1], arg_val[2], rhs_value); + mpf_mngr.sub(rm, est_arg_val[1], est_arg_val[2], est_rhs_value); + break; + case OP_FPA_NEG: + mpf_mngr.neg(arg_val[0], rhs_value); + mpf_mngr.neg(est_arg_val[0], est_rhs_value);//Does it even make sense to look at this? + break; + case OP_FPA_MUL: + mpf_mngr.mul(rm, arg_val[1], arg_val[2], rhs_value); + mpf_mngr.mul(rm, est_arg_val[1], est_arg_val[2], est_rhs_value); + break; + case OP_FPA_DIV: + mpf_mngr.div(rm, arg_val[1], arg_val[2], rhs_value); + mpf_mngr.div(rm, est_arg_val[1], est_arg_val[2], est_rhs_value); + break; + case OP_FPA_REM: + mpf_mngr.rem(arg_val[0], arg_val[1], rhs_value); + mpf_mngr.rem(est_arg_val[0], est_arg_val[1], est_rhs_value); + break; + case OP_FPA_FMA: + mpf_mngr.fused_mul_add(rm, arg_val[1], arg_val[2], arg_val[3], rhs_value); + mpf_mngr.fused_mul_add(rm, est_arg_val[1], est_arg_val[2], est_arg_val[3], est_rhs_value); + break; + case OP_FPA_SQRT: + mpf_mngr.sqrt(rm, arg_val[1], rhs_value); + mpf_mngr.sqrt(rm, est_arg_val[1], est_rhs_value); + break; + case OP_FPA_TO_FP: + { + unsigned ebits = rhs->get_decl()->get_parameter(0).get_int(); + unsigned sbits = rhs->get_decl()->get_parameter(1).get_int(); + mpf_mngr.set(rhs_value, ebits, sbits, rm, arg_val[1]); + mpf_mngr.set(est_rhs_value, ebits, sbits, rm, est_arg_val[1]); + break; + } + case OP_FPA_ABS: + { + mpf_mngr.abs(arg_val[0], rhs_value); + mpf_mngr.abs(est_arg_val[0], est_rhs_value); + break; + } + case OP_FPA_MIN: + { + mpf_mngr.minimum( arg_val[1], arg_val[2], rhs_value); + mpf_mngr.minimum( est_arg_val[1], est_arg_val[2], est_rhs_value); + break; + } + case OP_FPA_MAX: + { + mpf_mngr.maximum( arg_val[1], arg_val[2], rhs_value); + mpf_mngr.maximum( est_arg_val[1], est_arg_val[2], est_rhs_value); + break; + } + case OP_FPA_ROUND_TO_INTEGRAL: + { + mpf_mngr.round_to_integral(rm,arg_val[1],rhs_value); + mpf_mngr.round_to_integral(rm,est_arg_val[1],est_rhs_value); + break; + } + + default: + NOT_IMPLEMENTED_YET(); + break; + } + + } + + void evaluate_constant( + app * rhs, + model_ref const & mdl, + mpf_manager & mpf_mngr, + obj_map & actual_value, + mpf & rhs_value, + mpf & est_rhs_value){ + + expr_ref exp(m); + mdl->eval(rhs, exp, true); + m_float_util.is_numeral(exp, rhs_value); //OLD:is_value + + if (actual_value.contains(rhs)) + mpf_mngr.set(est_rhs_value, *actual_value.find(rhs)); + else { + mpf * tmp = alloc(mpf); + mpf_mngr.set(*tmp, rhs_value); + actual_value.insert(rhs, tmp); + mpf_mngr.set(est_rhs_value, rhs_value); + } + } + + void calculate_error( + expr_ref & lhs, + mpf_manager & mpf_mngr, + obj_map & precise_op, + obj_map & err_est, + mpf & lhs_value, + mpf & est_rhs_value, + bool children_have_finite_err){ + mpf err, rel_err; + if (!mpf_mngr.eq(lhs_value, est_rhs_value) && + !(mpf_mngr.is_nan(lhs_value) && mpf_mngr.is_nan(est_rhs_value))) { +#ifdef Z3DEBUG + std::cout << "Increasing precision of " << mk_ismt2_pp(lhs, m) << + " because " << mk_ismt2_pp(lhs, m) << " != " << + mpf_mngr.to_string(est_rhs_value) << std::endl; +#endif + //TODO: smarter adjustment to be implemented + precise_op.insert(lhs, false); + if (mpf_mngr.is_regular(lhs_value) && mpf_mngr.is_regular(est_rhs_value)) { + mpf_mngr.sub(MPF_ROUND_TOWARD_ZERO, est_rhs_value, lhs_value, err); + mpf_mngr.div(MPF_ROUND_TOWARD_ZERO, err, lhs_value, rel_err); + mpf_mngr.abs(rel_err); + } + else// One of the two is a special value; in this case the relative error is +INF + mpf_mngr.mk_pinf(11, 53, rel_err); + + if(children_have_finite_err) + err_est.insert(lhs, mpf_mngr.to_double(rel_err)); + +#ifdef Z3DEBUG + std::cout << "Error estimate: "<size(); j++) { + mdl->eval(g->form(j), res, true); + if (!m.is_true(res)) { + std::cout << "Failed: " << mk_ismt2_pp(g->form(j), m) << std::endl; + std::cout << "Evaluates to: " << mk_ismt2_pp(res, m) << std::endl; + is_model=false; + } + } + return is_model; + } + void evaluate_and_patch( + func_decl_ref_vector const & cnsts, + model_ref const & mdl, + model_ref & full_mdl, + goal_ref const & g, + obj_map & cnst2term_map, + obj_map & err_est) { + + mpf_manager & mpf_mngr = m_float_util.fm(); + expr_ref lhs(m), lhs_eval(m); + app * rhs; + mpf arg_val[4]; //First argument can be rounding mode + mpf est_arg_val[4]; + mpf lhs_value, rhs_value, est_rhs_value; + mpf_rounding_mode rm; + + mpf err, rel_err; + + + + obj_map precise_op; + obj_map actual_value; + while (precise_op.size() != cnst2term_map.size()) + for(unsigned i=0;ieval(lhs, lhs_eval, true); + + if (m_float_util.is_numeral(lhs_eval, lhs_value)) {//OLD:is_value + bool precise_children = true; + bool seen_all_children = true; + bool children_have_finite_err = true; + + obtain_values(rhs, mdl, full_mdl,mpf_mngr,cnst2term_map,precise_op,actual_value, + err_est, rm, precise_children, seen_all_children, children_have_finite_err, arg_val, est_arg_val ); + + + if (seen_all_children) {//If some arguments are not evaluated yet, skip + if (rhs->get_num_args() == 0) + evaluate_constant(rhs,mdl,mpf_mngr,actual_value, rhs_value, est_rhs_value); + else + full_semantics_eval(rhs,mpf_mngr,rm,arg_val,est_arg_val, rhs_value, est_rhs_value); + + if (mpf_mngr.eq(rhs_value, est_rhs_value)) { + full_mdl->register_decl((to_app(lhs))->get_decl(), m_float_util.mk_value(est_rhs_value)); + precise_op.insert(lhs, true); + } + else { + full_mdl->register_decl((to_app(lhs))->get_decl(), m_float_util.mk_value(est_rhs_value)); +#ifdef Z3DEBUG + std::cout << "Assigning " << mk_ismt2_pp(lhs, m) << + " value " << mpf_mngr.to_string(est_rhs_value) << std::endl + << "Values of " << mk_ismt2_pp(lhs, m) << std::endl + << "Precise children: " << ((precise_children) ? "True" : "False") << std::endl + << "Lhs: " << mk_ismt2_pp(lhs_eval, m) << std::endl + << "Model: " << mpf_mngr.to_string(rhs_value) << std::endl + << "Estimate: " << mpf_mngr.to_string(est_rhs_value) << std::endl; +#endif + + calculate_error(lhs,mpf_mngr,precise_op,err_est,lhs_value,est_rhs_value,children_have_finite_err); + + } + if (!actual_value.contains(lhs)) { + mpf * tmp = alloc(mpf); + mpf_mngr.set(*tmp, est_rhs_value); + actual_value.insert(lhs, tmp); + } + + if (!precise_children && !precise_op.contains(lhs)) { + std::cout << mk_ismt2_pp(lhs, m) << " is imprecise because some children are imprecise." << std::endl; + precise_op.insert(lhs, false); + } + } + } + } + + for (obj_map::iterator it = actual_value.begin(); + it != actual_value.end(); + it++) + mpf_mngr.del(*it->m_value); + + mpf_mngr.del(err); + mpf_mngr.del(rel_err); + mpf_mngr.del(lhs_value); + mpf_mngr.del(rhs_value); + mpf_mngr.del(est_rhs_value); + + for (unsigned i = 0; i < 4; i++) { + mpf_mngr.del(arg_val[i]); + mpf_mngr.del(est_arg_val[i]); + } + } + + bool precise_model_reconstruction( + model_ref const & mdl, + model_ref & full_mdl, + goal_ref const & g, + obj_map & err_est,//mpf* + func_decl_ref_vector const & cnsts, + obj_map & cnst2term_map) { +#ifdef Z3DEBUG + std::cout << "Attempting to patch small-float model" << std::endl; +#endif + expr_ref res(m); + bool is_model=true; + + //Evaluation of the model using full fpa semantics and construction of the full model + evaluate_and_patch(cnsts, mdl, full_mdl, g, cnst2term_map, err_est); + +#ifdef Z3DEBUG + std::cout<::iterator it = err_est.begin(); + it!= err_est.end(); it++) { + std::cout<m_key,m)<<":"<m_value<get_num_constants(); j++) { + if (!cnst2term_map.contains(mdl->get_constant(j)) + && !full_mdl->get_const_interp(mdl->get_constant(j))) { + mdl->eval(mdl->get_constant(j), res); + full_mdl->register_decl(mdl->get_constant(j), res); + } + } + + //Evaluate the full model + is_model = evaluate_model(g,full_mdl); + + return is_model; + } + + void calculate_relative_error( + obj_map & err_est, + obj_map & expr_count, + obj_map & err_ratio_map) { + unsigned num_args=0; + expr_ref exp(m); + double out_err,cur,err_ratio, avg_err; + + //AZ: Currently ignoring the expr_count, since it was blocking consideration of some expressions + for (obj_map::iterator it = err_est.begin(); + it != err_est.end(); + it++) { + // if any ancestor node has an error current node will be in expr_count. + /*if (!expr_count.contains(it->m_key)) + continue;*/ + + exp = it->m_key; + out_err = it->m_value; + num_args = to_app(exp)->get_num_args(); + + // Calculate average error of input params + avg_err = 0.0; + if (num_args > 0) { + for (unsigned i=0; iget_arg(i); + if (err_est.contains(arg)) { + cur = err_est.find(arg); + avg_err = avg_err + cur; + } + } + avg_err = avg_err/num_args; + } + // Relative error when input error exists, otherwise just output error + err_ratio = fabs((avg_err != (double) 0)? out_err / avg_err : out_err); + + if(expr_count.contains(exp)) { + if(ERR_OP) + err_ratio *= 1 + expr_count.find(exp); + else + err_ratio += expr_count.find(exp); + } + err_ratio_map.insert(exp, err_ratio); + } + + TRACE("fpa2bv_approx", + tout << "ERROR RATIO MAP: " << std::endl; + for (obj_map::iterator it = err_ratio_map.begin();// mpf* + it != err_ratio_map.end(); + it++) + tout << mk_ismt2_pp(it->m_key, m) << ": " <m_value<< std::endl; ); + + +#ifdef Z3DEBUG + std::cout<<"Error ratio:"<::iterator it = err_ratio_map.begin();//mpf* + it != err_ratio_map.end(); + it++) + std::cout<< mk_ismt2_pp(it->m_key, m) << ": " << it->m_value<< std::endl; + std::cout.flush(); +#endif + + } + + + void rank_terms(obj_map & err_ratio_map, std::list & ranked_terms) + { + unsigned kth = (unsigned)(err_ratio_map.size()*K_PERCENTAGE); + if (kth<10) kth=K_MIN; + SASSERT(!err_ratio_map.empty()); + + //Insertion sort the error ratios, keeping only the k highest elements + obj_map::iterator it = err_ratio_map.begin(); + struct pair * p = new struct pair(); + p->exp=it->m_key; + p->quotient=it->m_value; + ranked_terms.push_front(p); + + for (it++; it != err_ratio_map.end(); it++) { + if (ranked_terms.size()m_value >= ranked_terms.back()->quotient) { + std::list::iterator pos = ranked_terms.begin(); + while (pos!=ranked_terms.end() && it->m_value <= ranked_terms.back()->quotient) + pos++; + struct pair * p = new struct pair(); + p->exp=it->m_key; + p->quotient=it->m_value; + ranked_terms.insert(pos, p); + if (ranked_terms.size() > kth) { + delete ranked_terms.back(); + ranked_terms.pop_back(); + } + } + } + + } + + void increase_precision( + std::list & ranked_terms, + func_decl_ref_vector const & cnsts, + obj_map & cnst2prec_map, + obj_map & cnst2term_map, + obj_map & new_map){ + + //Refine chosen terms and find the any input 'variables' which are + //its immediate arguments and refine them as well +#ifdef Z3DEBUG + std::cout<<"Increasing precision:"<::iterator itp = ranked_terms.begin(); + itp != ranked_terms.end(); + itp++) { + app * cur = to_app((*itp)->exp); + func_decl * f = cur->get_decl(); + unsigned new_prec = PREC_INCREMENT, old_prec; + bool in_new_map; + + if (cnst2prec_map.contains(f)) + new_prec += cnst2prec_map.find(f); + + new_prec= (new_prec > MAX_PRECISION) ? MAX_PRECISION : new_prec; + new_map.insert(f, new_prec); + +#ifdef Z3DEBUG + std::cout << f->get_name() << ":" << new_prec << std::endl; + std::cout << mk_ismt2_pp(cur, m) << ":" << new_prec << std::endl; +#endif + + if(cnst2term_map.contains(f)) + cur = cnst2term_map.find(f); + // Refine constants that are direct arguments of this term + for(unsigned i=0; iget_num_args();i++){ + func_decl * arg_decl = to_app(cur->get_arg(i))->get_decl(); + if (!cnst2term_map.contains(arg_decl) && //Not a constant introduced by flattening + !m_float_util.is_rm(cur->get_arg(i)) && //OLD:is_rm(...,rm) + !m_float_util.is_numeral(cur->get_arg(i))) { //OLD:is_value + //It is an input 'variable' + if ( (in_new_map = new_map.contains(arg_decl))) + old_prec=new_map.find(arg_decl); + else if (cnst2prec_map.contains(arg_decl)) + old_prec = cnst2prec_map.find(arg_decl); + else + old_prec=0; + + if (old_prec < new_prec) { + if (in_new_map) + new_map.remove(arg_decl); + SASSERT(new_prec <= MAX_PRECISION); + new_map.insert(arg_decl, new_prec); + std::cout << " " << arg_decl->get_name() << ":" << new_prec << std::endl; +#ifdef Z3DEBUG + std::cout<<" "<get_arg(i),m)<<":"< & cnst2prec_map, + obj_map & cnst2term_map, + obj_map & err_est, + obj_map & new_map) { + + obj_map err_ratio_map; + obj_map expr_count; + std::list ranked_terms; + + boolean_comparison_of_models(g, mdl, full_mdl, cnst2term_map, expr_count); + calculate_relative_error(err_est, expr_count, err_ratio_map); + if (err_ratio_map.empty()) { + proof_guided_refinement(g,cnsts,cnst2prec_map,new_map); + } + else { + rank_terms (err_ratio_map,ranked_terms); + increase_precision(ranked_terms,cnsts,cnst2prec_map,cnst2term_map,new_map); + } + } + + void simplify(goal_ref mg) { + ast_manager &m = mg->m(); // CMW: <--- We use the manager of the goal, so this works for any manager. + expr_ref new_curr(m); + proof_ref new_pr(m); + + th_rewriter simplifier(m, m_params); + + // CMW: we need to eliminate AND expressions. + params_ref elim_and(m_params); + elim_and.set_bool("elim_and", true); + // elim_and.set_uint("max_depth", 1); // CMW: This number can have a big impact on performance, either way. + simplifier.updt_params(elim_and); + + SASSERT(mg->is_well_sorted()); + TRACE("before_simplifier", mg->display(tout);); + m_num_steps = 0; + if (mg->inconsistent()) + return; + for (unsigned idx = 0; idx < mg->size(); idx++) { + if (mg->inconsistent()) + break; + expr * curr = mg->form(idx); + simplifier(curr, new_curr, new_pr); + m_num_steps += simplifier.get_num_steps(); + if (mg->proofs_enabled()) { + proof * pr = mg->pr(idx); + new_pr = m.mk_modus_ponens(pr, new_pr); + } + mg->update(idx, new_curr, new_pr, mg->dep(idx)); + } + TRACE("after_simplifier_bug", mg->display(tout);); + mg->elim_redundancies(); + TRACE("after_simplifier", mg->display(tout);); + TRACE("after_simplifier_detail", mg->display_with_dependencies(tout);); + SASSERT(mg->is_well_sorted()); + } + + bool fully_encoded(obj_map const & precision_map) + { + for (obj_map::iterator it = precision_map.begin(); + it != precision_map.end(); + it++) + if (it->m_value < MAX_PRECISION) return false; + return true; + } + + void bitblast(goal_ref const & g, + fpa2bv_converter_prec & fpa2bv, + bit_blaster_rewriter & bv2bool, + obj_map & const2prec_map, + sat::solver & solver, + atom2bool_var & map) + { + // CMW: This is all done using the temporary manager! + expr_ref new_curr(*m_temp_manager); + proof_ref new_pr(*m_temp_manager); + std::cout.flush(); + + SASSERT(g->is_well_sorted()); + + simplify(g); + + //fpa2bv + fpa2bv_rewriter_prec fpa2bv_rw(*m_temp_manager, fpa2bv, m_params); + fpa2bv_rw.m_cfg.set_mappings(&const2prec_map); + m_num_steps = 0; + unsigned size = g->size(); + for (unsigned idx = 0; idx < size; idx++) { + if (g->inconsistent()) + break; + expr * curr = g->form(idx); +#ifdef Z3DEBUG + std::cout<pr(idx); + new_pr = m_temp_manager->mk_modus_ponens(pr, new_pr); + } + g->update(idx, new_curr, new_pr, g->dep(idx)); + + SASSERT(g->is_well_sorted()); + } + + //Adding the equalities that fix bits + for(unsigned i=0;iassert_expr(fpa2bv.m_extra_assertions.get(i)); + + SASSERT(g->is_well_sorted()); + + simplify(g); + + //Bitblasting + TRACE("before_bit_blaster", g->display(tout);); + m_num_steps = 0; + size = g->size(); + for (unsigned idx = 0; idx < size; idx++) { + if (g->inconsistent()) + break; + expr * curr = g->form(idx); + bv2bool(curr, new_curr, new_pr); + m_num_steps += bv2bool.get_num_steps(); + if (m_proofs_enabled) { + proof * pr = g->pr(idx); + new_pr = m_temp_manager->mk_modus_ponens(pr, new_pr); + } + g->update(idx, new_curr, new_pr, g->dep(idx)); + } + + g->inc_depth(); + + simplify(g); + + TRACE("before_sat_solver", g->display(tout);); + g->elim_redundancies(); + + goal2sat::dep2asm_map d2am ; + m_goal2sat(*g, m_params, solver, map, d2am , false); + + + TRACE("sat_solver_unknown", tout << "interpreted_atoms: " << map.interpreted_atoms() << "\n"; + atom2bool_var::iterator it = map.begin(); + atom2bool_var::iterator end = map.end(); + for (; it != end; ++it) { + if (!is_uninterp_const(it->m_key)) + tout << mk_ismt2_pp(it->m_key, *m_temp_manager) << "\n"; + }); + + CASSERT("sat_solver", solver.check_invariant()); + IF_VERBOSE(TACTIC_VERBOSITY_LVL, solver.display_status(verbose_stream());); + TRACE("sat_dimacs", solver.display_dimacs(tout);); + } + + model_ref get_fpa_model(goal_ref const & g, + fpa2bv_converter_prec & fpa2bv, + bit_blaster_rewriter & bv2bool, + sat::solver & solver, + atom2bool_var & map) { + // CMW: This is all done using the temporary manager, until at the very end we translate the model back to this->m. + model_ref md = alloc(model, *m_temp_manager); + sat::model const & ll_m = solver.get_model(); + TRACE("sat_tactic", for (unsigned i = 0; i < ll_m.size(); i++) + tout << i << ":" << ll_m[i] << " "; tout << "\n";); + atom2bool_var::iterator it = map.begin(); + atom2bool_var::iterator end = map.end(); + for (; it != end; ++it) { + expr * n = it->m_key; + sat::bool_var v = it->m_value; + if (is_app(n) && to_app(n)->get_decl()->get_arity() != 0) + continue; + TRACE("sat_tactic", tout << "extracting value of " << mk_ismt2_pp(n, *m_temp_manager) << "\nvar: " << v << "\n";); + switch (sat::value_at(v, ll_m)) { + case l_true: md->register_decl(to_app(n)->get_decl(), m_temp_manager->mk_true()); break; + case l_false: md->register_decl(to_app(n)->get_decl(), m_temp_manager->mk_false()); break; + default: + break; + } + } + + TRACE("sat_tactic", model_v2_pp(tout, *md);); + model_converter_ref bb_mc = mk_bit_blaster_model_converter(*m_temp_manager, bv2bool.const2bits()); + + model_converter_ref bv_mc = mk_fpa2bv_model_converter(*m_temp_manager, fpa2bv.const2bv(), fpa2bv.rm_const2bv(), fpa2bv.uf2bvuf(), fpa2bv.uf23bvuf()); + bb_mc->operator()(md, 0); + bv_mc->operator()(md, 0); + +#ifdef Z3DEBUG + std::cout << "Model: " << std::endl; + for (unsigned i = 0 ; i < md->get_num_constants(); i++) { + func_decl * d = md->get_constant(i); + std::cout << d->get_name() << " = " << mk_ismt2_pp(md->get_const_interp(d), *m_temp_manager) << std::endl; + } +#endif + // md is in terms of the temporary manager. + ast_translation translator(*m_temp_manager, this->m); + return md->translate(translator); + } + + void encode_fpa_terms( goal_ref const & g, + obj_map & const2term_map) + { + for (obj_map::iterator it = const2term_map.begin(); + it!=const2term_map.end(); + it++) { + expr_ref q(m); +#ifdef Z3DEBUG + std::cout << "Adding " << it->m_key->get_name() << " = " << mk_ismt2_pp(it->m_value, m) << std::endl; +#endif + q = m.mk_eq(m.mk_const(it->m_key), it->m_value); + g->assert_expr(q); + } + } + + lbool approximate_model_construction(goal_ref & g, obj_map & const2prec_map) { + lbool r = l_undef; + // CMW: The following will introduce lots of stuff that we don't need (e.g., symbols) + // To save memory, we use a separate, new manager that we can throw away afterwards. + m_temp_manager = alloc(ast_manager, PGM_DISABLED); + { + ast_translation translator(m, *m_temp_manager); + goal_ref ng = g->translate(translator); + obj_map const2prec_map_tm; + + for (obj_map::iterator it = const2prec_map.begin(); + it!=const2prec_map.end(); + it++) + const2prec_map_tm.insert(translator(it->m_key), it->m_value); + + sat::solver sat_solver(m_params, 0); + atom2bool_var atom_map(*m_temp_manager); + { tactic_report report_i("fpa2bv_approx_before_bitblaster", *ng); } + fpa2bv_converter_prec fpa2bv(*m_temp_manager, m_mode); + bit_blaster_rewriter bv2bool(*m_temp_manager, m_params); + bitblast(ng, fpa2bv, bv2bool, const2prec_map_tm, sat_solver, atom_map); + { tactic_report report_i("fpa2bv_approx_after_bitblaster", *ng); } + + std::cout << "Iteration variables: " << sat_solver.num_vars() << std::endl; + std::cout << "Iteration clauses: " << sat_solver.num_clauses() << std::endl; + r = sat_solver.check(); + + if (r == l_true) + { + // we need to get the model and translate it back to m. + m_fpa_model = get_fpa_model(ng, fpa2bv, bv2bool, sat_solver, atom_map).get(); + } + else + m_fpa_model = 0; + + // CMW: translator, etc, gets destroyed here, so all references + // to temporary expressions are gone. + } + + dealloc(m_temp_manager); + m_temp_manager = 0; + + return r; + } + + void lift( goal_ref const & g, func_decl_ref_vector & constants, obj_map * const2term_map ) + { + expr_ref new_new_curr(m); + expr_ref new_curr(m); + proof_ref new_pr(m); + + simplify(g); + + //Renaming subexpressions using new constants + const_intro_rewriter const_rewriter(m, m_params); + for (unsigned idx = 0; idx < g->size(); idx++) { + if (g->inconsistent()) + break; + expr * curr = g->form(idx); + const_rewriter(curr, new_curr, new_pr); //Introduces constants that replace subexpressions + m_num_steps += const_rewriter.get_num_steps(); + if (m_proofs_enabled) { + proof * pr = g->pr(idx); + new_pr = m.mk_modus_ponens(pr, new_pr); + } + g->update(idx, new_curr, new_pr, g->dep(idx)); + } + + + constants.set(const_rewriter.m_cfg.m_introduced_consts); + const2term_map->swap(const_rewriter.m_cfg.m_const2term_map); + + // Note: Ideally, we would directly encode them. For now we're lazy and just add equalities + // and we rely on fpa2bv_converter_prec to `magically' recognize the equalities we added. + { tactic_report report_i("fpa2bv_approx_before_fpa_terms", *(g.get())); } + encode_fpa_terms(g, *const2term_map); + SASSERT(g.get()->is_well_sorted()); + + + } + + void verify_precise_model( goal_ref const & g, + model_ref & full_mdl, + func_decl_ref_vector & constants, + obj_map & const2term_map, + model_converter_ref & mc, + goal_ref_buffer & result ){ + expr_ref res(m); + + for (unsigned j = 0; j < g->size(); j++) { + full_mdl->eval(g->form(j), res, true); + if (!m.is_true(res)) { + std::cout << "Failed: " << mk_ismt2_pp(g->form(j), m) << std::endl; + std::cout << "Evaluates to: " << mk_ismt2_pp(res, m) << std::endl; + } + SASSERT(m.is_true(res)); + } + + std::cout << "Full model: " << std::endl; + for (unsigned i = 0 ; i < full_mdl->get_num_decls(); i++) + { + func_decl * d = full_mdl->get_decl(i); + if(constants.contains(d)) + std::cout << d->get_name() << " = " << mk_ismt2_pp(full_mdl->get_const_interp(d), m) << std::endl; + } + std::cout.flush(); + + result.back()->reset(); + + // Filter all the constants we introduced earlier from the model. + filter_model_converter * fmc = alloc(filter_model_converter, m); + for (obj_map::iterator it = const2term_map.begin(); + it != const2term_map.end(); + it++) + fmc->insert(it->m_key); + mc = concat(fmc, model2model_converter(m_fpa_model.get())); + } + + void setup_options(goal_ref const & g){ + SASSERT(g->is_well_sorted()); + fail_if_proof_generation("fpa2bv_approx", g); + fail_if_unsat_core_generation("fpa2bv_approx", g); + m_proofs_enabled = g->proofs_enabled(); + m_produce_models = g->models_enabled(); + m_produce_unsat_cores = g->unsat_core_enabled(); + m_num_steps = 0; + } + + + + void print_constants(func_decl_ref_vector & constants, obj_map & const2prec_map){ +#ifdef Z3DEBUG + for(unsigned i=0;iget_name()<<":"< const2prec_map; + obj_map next_const2prec_map; + func_decl_ref_vector constants(m); + obj_map const2term_map; + lbool r = l_true; + unsigned iteration_cnt = 0; + stopwatch sw; + + tactic_report report("fpa2bv_approx", *g); + TRACE("fpa2bv_approx", tout << "BEFORE: " << std::endl; g->display(tout);); + result.reset(); + result.push_back(g.get()); + + SASSERT(g->is_well_sorted()); + if (g->inconsistent()) + return; + + lift(g, constants, &const2term_map); + + init_precision_mapping(constants, const2prec_map, const2term_map); + + std::cout << "Simplified goal:" << std::endl; + g->display(std::cout); + + while (!solved && !m_cancel) + { + std::cout << "=============== Starting iteration " << ++iteration_cnt << std::endl; + + sw.reset(); + sw.start(); + + // Copy the goal + goal_ref mg(alloc(goal, g->m(),g->proofs_enabled(),g->models_enabled(),g->unsat_core_enabled())); + mg->copy_from(*g.get()); + tactic_report report_i("fpa2bv_approx_i", *mg); + + print_constants(constants, const2prec_map); + + TRACE("fpa2bv_approx_goal_i", mg->display(tout); ); + + r = approximate_model_construction(mg, const2prec_map); + + std::cout << "Approximation is " << (r==l_true?"SAT":r==l_false?"UNSAT":"UNKNOWN") << std::endl; + + if (r == l_true) { + model_ref full_mdl = alloc(model, m); + obj_map err_est; + + if (fully_encoded(const2prec_map)) { + full_mdl = m_fpa_model; + solved = true; + std::cout<<"Model is at full precision, no patching needed!"< This is unsat. + solved = true; + result.back()->reset(); + result.back()->assert_expr(m.mk_false()); + } + } else { + // CMW: When the sat solver comes back with `unknown', what shall we do? + // AZ: Blindly refine? + m_cancel = true; + } + + const2prec_map.swap(next_const2prec_map); + next_const2prec_map.reset(); + std::cout << "Iteration time: " << sw.get_current_seconds() << std::endl; + } + + std::cout << "=============== Terminating " << std::endl; + dec_ref_map_key_values(m, const2term_map); + std::cout << "Iteration count: " << iteration_cnt << std::endl; + } + }; + + imp * m_imp; + params_ref m_params; + +public: + fpa2bv_approx_tactic(ast_manager & m, params_ref const & p) : + m_params(p){ + m_imp = alloc(imp, m, p, FPAA_DEFAULT_MODE); + } + + virtual tactic * translate(ast_manager & m) { + return alloc(fpa2bv_approx_tactic, m, m_params); + } + + virtual ~fpa2bv_approx_tactic() { + dealloc(m_imp); + } + + virtual void updt_params(params_ref const & p) { + m_params = p; + m_imp->updt_params(p); + } + + virtual void collect_param_descrs(param_descrs & r) { + } + + virtual void operator()(goal_ref const & in, goal_ref_buffer & result, + model_converter_ref & mc, proof_converter_ref & pc, + expr_dependency_ref & core) { + (*m_imp)(in, result, mc, pc, core); + } + + virtual void cleanup() { + ast_manager & m = m_imp->m; + imp * d = m_imp; +#pragma omp critical (tactic_cancel) + { + d = m_imp; + } + dealloc(d); + d = alloc(imp, m, m_params, FPAA_DEFAULT_MODE); +#pragma omp critical (tactic_cancel) + { + m_imp = d; + } + } + +protected: + virtual void set_cancel(bool f) { + if (m_imp) + m_imp->set_cancel(f); +} +}; + +tactic * mk_fpa2bv_approx_tactic(ast_manager & m, params_ref const & p) { + return and_then(clean(alloc(fpa2bv_approx_tactic, m, p)), mk_fail_if_undecided_tactic()); +} + + diff --git a/src/tactic/fpa/fpa2bv_approx_tactic.h b/src/tactic/fpa/fpa2bv_approx_tactic.h new file mode 100644 index 00000000000..8838ca99d79 --- /dev/null +++ b/src/tactic/fpa/fpa2bv_approx_tactic.h @@ -0,0 +1,33 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + fpa2bv_lazy_tactic.h + +Abstract: + + Tactic that converts floating points to bit-vectors lazily + +Author: + + Aleksander Zeljic 2012-11-15 + +Notes: + +--*/ +#ifndef _FPA2BV_APPROX_TACTIC_ +#define _FPA2BV_APPROX_TACTIC_ + +#include"params.h" +class ast_manager; +class tactic; + + + +tactic * mk_fpa2bv_approx_tactic(ast_manager & m, params_ref const & p = params_ref()); +/* + ADD_TACTIC("fpa2bv_approx", "An iterative approximation based bit-blasting decision procedure for FPA.", "mk_fpa2bv_approx_tactic(m, p)") +*/ + +#endif diff --git a/src/tactic/fpa/fpa2bv_converter_prec.cpp b/src/tactic/fpa/fpa2bv_converter_prec.cpp new file mode 100644 index 00000000000..0465111994b --- /dev/null +++ b/src/tactic/fpa/fpa2bv_converter_prec.cpp @@ -0,0 +1,1594 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + fpa2bv_converter_prec.cpp + +Abstract: + + Conversion routines for Floating Point -> Bit-Vector + +Author: + + Christoph (cwinter) 2012-02-09 + +Notes: + +--*/ +#include"ast_smt2_pp.h" +#include"well_sorted.h" +#include + +#include"fpa2bv_converter_prec.h" + +#define BVULT(X,Y,R) { expr_ref bvult_eq(m), bvult_not(m); m_simp.mk_eq(X, Y, bvult_eq); m_simp.mk_not(bvult_eq, bvult_not); expr_ref t(m); t = m_bv_util.mk_ule(X,Y); m_simp.mk_and(t, bvult_not, R); } +#define BVSLT(X,Y,R) { expr_ref bvslt_eq(m), bvslt_not(m); m_simp.mk_eq(X, Y, bvslt_eq); m_simp.mk_not(bvslt_eq, bvslt_not); expr_ref t(m); t = m_bv_util.mk_sle(X,Y); m_simp.mk_and(t, bvslt_not, R); } + +#define MIN_EBITS 3 +#define MIN_SBITS 3 + +fpa2bv_converter_prec::fpa2bv_converter_prec(ast_manager & m, fpa_approximation_mode mode) : + fpa2bv_converter(m), + m_mode(mode) { +} + +void fpa2bv_converter_prec::fix_bits(unsigned prec, expr_ref rounded, unsigned sbits, unsigned ebits)//expr_ref& fixed, +{ //AZ: TODO: revise! minimal number of legal bits is 3!!!! Remove magic numbers + unsigned szeroes = (unsigned) ((sbits-2)*(MAX_PRECISION - prec +0.0) / MAX_PRECISION);//3 bits are minimum for the significand + unsigned ezeroes = (unsigned) ((ebits - 2)*(MAX_PRECISION - prec + 0.0) / MAX_PRECISION);//2 bits are minimum for the exponent + + expr_ref fix_sig(m), fix_exp(m); + expr * sgn, *sig, *expn; + split_fp( rounded.get(), sgn,sig,expn); + if(ezeroes>0) { + fix_exp=m.mk_eq(m_bv_util.mk_extract(ebits-2, ebits - ezeroes -1, sig), m_bv_util.mk_numeral(0,ezeroes)); + m_extra_assertions.push_back(fix_exp); + SASSERT(is_well_sorted(m, fix_exp)); + } + + if(szeroes>0) { + fix_sig=m.mk_eq(m_bv_util.mk_extract(sbits-2, sbits - szeroes -1, sig), m_bv_util.mk_numeral(0,szeroes)); + m_extra_assertions.push_back(fix_sig); + SASSERT(is_well_sorted(m, fix_sig)); + } +} + +void fpa2bv_converter_prec::mk_const(func_decl * f, unsigned prec, expr_ref & result) { + switch (m_mode) { + case FPAA_SMALL_FLOATS: + { + if (m_const2bv.contains(f)) + result = m_const2bv.find(f); + else { + if (prec == MAX_PRECISION) + fpa2bv_converter::mk_const(f, result); + else { + unsigned ebits = fu().get_ebits(f->get_range()); + unsigned sbits = fu().get_sbits(f->get_range()); + double rel = prec/(double)MAX_PRECISION; + unsigned new_ebits = (unsigned) (rel * (double)ebits); + unsigned new_sbits = (unsigned) (rel * (double)sbits); + if (new_ebits < MIN_EBITS) new_ebits = MIN_EBITS; + if (new_sbits < MIN_SBITS) new_sbits = MIN_SBITS; + sort_ref ns(m), fp_srt(m); + ns = fu().mk_float_sort(new_ebits, new_sbits); + app_ref small_const(m); + small_const = m.mk_fresh_const("small_const", ns); + + fp_srt = fu().mk_float_sort(ebits, sbits); + symbol name("asFloat"); + sort_ref rm_sort(m); + rm_sort = fu().mk_rm_sort(); + //sort * domain[2] = { rm_sort, ns }; + //parameter parameters[2] = { parameter(ebits), parameter(sbits) }; + + fpa2bv_converter::mk_const(small_const->get_decl(), result); + m_const2bv.insert(f, result.get()); + m.inc_ref(f); + m.inc_ref(result.get()); +#ifdef Z3DEBUG + std::cout << f->get_name() << " := " << small_const->get_decl()->get_name() << + " [" << new_sbits<<","<get_name() << " := " << mk_ismt2_pp(result, m) << std::endl;); + } + } + break; + } + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_const(f, result); break; + default: + UNREACHABLE(); + break; + } +} +void fpa2bv_converter_prec::mk_small_op(func_decl * f, unsigned new_ebits, unsigned new_sbits, unsigned num, expr * const * args, func_decl_ref & small_op, expr_ref_vector & cast_args) +{ + if (new_ebits < MIN_EBITS) new_ebits = MIN_EBITS; + if (new_sbits < MIN_SBITS) new_sbits = MIN_SBITS; + sort_ref new_srt(m), rm_srt(m); + new_srt = fu().mk_float_sort(new_ebits, new_sbits); + rm_srt = fu().mk_rm_sort(); + + sort_ref_vector new_domain(m); + cast_args.reset(); + + for (unsigned i=0; i < num; i++) // Recreate the domain by replacing the full fpa sort with the smaller one. + { + sort * d_i = f->get_domain(i); + expr * a_i = args[i]; + + if (fu().is_rm(d_i)) + { + new_domain.push_back(rm_srt); + cast_args.push_back(a_i); + } + else if (fu().is_float(f->get_domain(i))) + { + sort * a_i_srt = to_app(a_i)->get_decl()->get_range(); + new_domain.push_back(new_srt); + + // Cast the corresponding argument to the right fpa size + if (is_app(a_i)) + { + if (a_i_srt == new_srt) + cast_args.push_back(a_i); + else { + app_ref rtz(m); + rtz = fu().mk_round_toward_zero(); + expr_ref rm(m); + fpa2bv_converter::mk_rounding_mode(rtz->get_decl(), rm); + + sort * d[2] = { rm_srt, a_i_srt }; + symbol name("asFloat"); + func_decl_ref fd(m); + fd = m.mk_func_decl(name, 2, d, new_srt, func_decl_info(fu().get_family_id(), OP_FPA_TO_FP, new_srt->get_num_parameters(), new_srt->get_parameters())); + + expr_ref t(m); + expr * args[2] = { rm, a_i }; + fpa2bv_converter::mk_to_fp(fd, 2, args, t); + cast_args.push_back(t); + SASSERT(is_well_sorted(m, t)); + } + } + else + NOT_IMPLEMENTED_YET(); + } + else + // just keep everything else + cast_args.push_back(a_i); + } + + parameter parameters[2] = { parameter(new_ebits), parameter(new_sbits) }; + + // May I reuse parts of the existing declaration? CMW: Sure. + + small_op = m.mk_func_decl(f->get_name(), num, new_domain.c_ptr(), new_srt, + func_decl_info(fu().get_family_id(), f->get_decl_kind(), 2, parameters)); + + //std::cout<get_name()<<"["<get_range()); + unsigned sbits = fu().get_sbits(f->get_range()); + double rel = prec/(double)MAX_PRECISION; + unsigned new_ebits = (unsigned) (rel * (double)ebits);// (unsigned) (MIN_EBITS + rel * (double)(ebits-MIN_EBITS)) + unsigned new_sbits = (unsigned) (rel * (double)sbits);// (unsigned) (MIN_SBITS + rel * (double)(sbits-MIN_SBITS)) + mk_small_op(f,new_ebits,new_sbits,num,args, small_op, cast_args); +} + +void fpa2bv_converter_prec::mk_cast_small_to_big(func_decl * f, expr * arg, expr_ref & result) { + unsigned ebits = fu().get_ebits(f->get_range()); + unsigned sbits = fu().get_sbits(f->get_range()); + + app_ref rtz(m); + rtz = fu().mk_round_toward_zero(); + expr_ref rm(m); + fpa2bv_converter::mk_rounding_mode(rtz->get_decl(), rm); + sort_ref rm_srt(m); + rm_srt = fu().mk_rm_sort(); + sort * d[2] = { rm_srt, to_app(arg)->get_decl()->get_range() }; + parameter parameters[2] = { parameter(ebits), parameter(sbits) }; + symbol name("asFloat"); + func_decl_ref cast_up(m); + cast_up = m.mk_func_decl(name, 2, d, f->get_range(), func_decl_info(fu().get_family_id(), OP_FPA_TO_FP, f->get_range()->get_num_parameters(), parameters)); + expr * args[2] = { rm, arg }; + fpa2bv_converter::mk_to_fp(cast_up, 2, args, result); +} + +void fpa2bv_converter_prec::mk_cast_small_to_big(unsigned sbits, unsigned ebits, expr * arg, expr_ref & result) { + app_ref rtz(m); + rtz = fu().mk_round_toward_zero(); + expr_ref rm(m); + fpa2bv_converter::mk_rounding_mode(rtz->get_decl(), rm); + sort_ref rm_srt(m); + rm_srt = fu().mk_rm_sort(); + sort * d[2] = { rm_srt, to_app(arg)->get_decl()->get_range() }; + parameter parameters[2] = { parameter(ebits), parameter(sbits) }; + symbol name("asFloat"); + func_decl_ref cast_up(m); + sort_ref ns(m); + ns = fu().mk_float_sort(ebits, sbits); + cast_up = m.mk_func_decl(name, 2, d, ns, func_decl_info(fu().get_family_id(), OP_FPA_TO_FP, 2, parameters)); + expr * args[2] = { rm, arg }; + fpa2bv_converter::mk_to_fp(cast_up, 2, args, result); +} + + +void fpa2bv_converter_prec::match_sorts(expr * a, expr * b, expr_ref & n_a, expr_ref & n_b) +{ + //Check if the sorts of lhs and rhs match, otherwise cast them to appropriate size? + SASSERT(is_app_of(a, m_plugin->get_family_id(), OP_FPA_FP)); + SASSERT(is_app_of(b, m_plugin->get_family_id(), OP_FPA_FP)); + func_decl * a_decl = to_app(a)->get_decl(); + func_decl * b_decl = to_app(b)->get_decl(); + + unsigned a_ebits = fu().get_ebits(a_decl->get_range()); + unsigned a_sbits = fu().get_sbits(a_decl->get_range()); + unsigned b_ebits = fu().get_ebits(b_decl->get_range()); + unsigned b_sbits = fu().get_sbits(b_decl->get_range()); + unsigned n_ebits, n_sbits; + + //if( (a_ebits == b_ebits) && (a_sbits == b_sbits)) + //{//No need for adjustment + n_a = a; + n_b = b; + //} + //else + //{ + if ((a_ebits <= b_ebits) && (a_sbits<= b_sbits)) + {//sort of b is wider than sort of a, we cast a to the sort of b. + mk_cast_small_to_big(b_sbits,b_ebits,a,n_a); + n_b = b; + } + else if ((a_ebits >= b_ebits) && (a_sbits >= b_sbits)) + { + n_a = a; + mk_cast_small_to_big(a_sbits,a_ebits,b,n_b); + } + else + { + n_ebits = (a_ebits < b_ebits)? b_ebits:a_ebits; + n_sbits = (a_sbits < b_sbits)? b_sbits:a_sbits; + mk_cast_small_to_big(n_sbits,n_ebits,a,n_a); + mk_cast_small_to_big(n_sbits,n_ebits,b,n_b); + } + //} +} +void fpa2bv_converter_prec::mk_eq(expr * a, expr * b, expr_ref & result) { + // This is structural equality, not floating point equality. + expr_ref na(m),nb(m); + match_sorts(a,b,na,nb); + fpa2bv_converter::mk_eq(na,nb,result); +} + +void fpa2bv_converter_prec::mk_ite(expr * c, expr * t, expr * f, expr_ref & result) { + expr_ref nt(m),nf(m); + match_sorts(t,f,nt,nf); + fpa2bv_converter::mk_ite(c,nt,nf,result); +} + + + +void fpa2bv_converter_prec::mk_add(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + // AZ: Switch can be moved just before the call to the fix_bits method, everything else should be the same + switch (m_mode) { + case FPAA_PRECISE: + fpa2bv_converter::mk_add(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + //expr_ref small_op(m); + fpa2bv_converter::mk_add(small_fd, num, small_args.c_ptr(), result); + //mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << "small_fd: " << mk_ismt2_pp(small_fd, m) << std::endl << + "result = " << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + + case FPAA_FIXBITS: { + if (MAX_PRECISION == prec) + fpa2bv_converter::mk_add(f,num,args,result); + else{ + //Alternative encoding + /*func_decl * nf = & func_decl(f->get_name(), + f->get_arity(), + f->get_domain(), + f->get_range(), + f->get_info());*/ + + + SASSERT(num == 3); + + expr_ref rm(m), x(m), y(m); + rm = args[0]; + x = args[1]; + y = args[2]; + + expr_ref nan(m), nzero(m), pzero(m); + mk_nan(f, nan); + mk_nzero(f, nzero); + mk_pzero(f, pzero); + + expr_ref x_is_nan(m), x_is_zero(m), x_is_pos(m), x_is_neg(m), x_is_inf(m); + expr_ref y_is_nan(m), y_is_zero(m), y_is_pos(m), y_is_neg(m), y_is_inf(m); + mk_is_nan(x, x_is_nan); + mk_is_zero(x, x_is_zero); + mk_is_pos(x, x_is_pos); + mk_is_neg(x, x_is_neg); + mk_is_inf(x, x_is_inf); + mk_is_nan(y, y_is_nan); + mk_is_zero(y, y_is_zero); + mk_is_pos(y, y_is_pos); + mk_is_neg(y, y_is_neg); + mk_is_inf(y, y_is_inf); + + dbg_decouple("fpa2bv_add_x_is_nan", x_is_nan); + dbg_decouple("fpa2bv_add_x_is_zero", x_is_zero); + dbg_decouple("fpa2bv_add_x_is_pos", x_is_pos); + dbg_decouple("fpa2bv_add_x_is_neg", x_is_neg); + dbg_decouple("fpa2bv_add_x_is_inf", x_is_inf); + dbg_decouple("fpa2bv_add_y_is_nan", y_is_nan); + dbg_decouple("fpa2bv_add_y_is_zero", y_is_zero); + dbg_decouple("fpa2bv_add_y_is_pos", y_is_pos); + dbg_decouple("fpa2bv_add_y_is_neg", y_is_neg); + dbg_decouple("fpa2bv_add_y_is_inf", y_is_inf); + + expr_ref c1(m), c2(m), c3(m), c4(m), c5(m), c6(m); + expr_ref v1(m), v2(m), v3(m), v4(m), v5(m), v6(m), v7(m); + + m_simp.mk_or(x_is_nan, y_is_nan, c1); + v1 = nan; + + mk_is_inf(x, c2); + expr_ref nx(m), ny(m), nx_xor_ny(m), inf_xor(m); + mk_is_neg(x, nx); + mk_is_neg(y, ny); + m_simp.mk_xor(nx, ny, nx_xor_ny); + m_simp.mk_and(y_is_inf, nx_xor_ny, inf_xor); + mk_ite(inf_xor, nan, x, v2); + + mk_is_inf(y, c3); + expr_ref xy_is_neg(m), v3_and(m); + m_simp.mk_xor(x_is_neg, y_is_neg, xy_is_neg); + m_simp.mk_and(x_is_inf, xy_is_neg, v3_and); + mk_ite(v3_and, nan, y, v3); + + expr_ref rm_is_to_neg(m), signs_and(m), signs_xor(m), v4_and(m), rm_and_xor(m), neg_cond(m); + m_simp.mk_and(x_is_zero, y_is_zero, c4); + m_simp.mk_and(x_is_neg, y_is_neg, signs_and); + m_simp.mk_xor(x_is_neg, y_is_neg, signs_xor); + mk_is_rm(rm, BV_RM_TO_NEGATIVE, rm_is_to_neg); + m_simp.mk_and(rm_is_to_neg, signs_xor, rm_and_xor); + m_simp.mk_or(signs_and, rm_and_xor, neg_cond); + mk_ite(neg_cond, nzero, pzero, v4); + m_simp.mk_and(x_is_neg, y_is_neg, v4_and); + mk_ite(v4_and, x, v4, v4); + + c5 = x_is_zero; + v5 = y; + + c6 = y_is_zero; + v6 = x; + + // Actual addition. + unsigned ebits = m_util.get_ebits(f->get_range()); + unsigned sbits = m_util.get_sbits(f->get_range()); + + expr_ref a_sgn(m), a_sig(m), a_exp(m), a_lz(m), b_sgn(m), b_sig(m), b_exp(m), b_lz(m); + unpack(x, a_sgn, a_sig, a_exp, a_lz, false); + unpack(y, b_sgn, b_sig, b_exp, b_lz, false); + + dbg_decouple("fpa2bv_add_unpack_a_sgn", a_sgn); + dbg_decouple("fpa2bv_add_unpack_a_sig", a_sig); + dbg_decouple("fpa2bv_add_unpack_a_exp", a_exp); + dbg_decouple("fpa2bv_add_unpack_b_sgn", b_sgn); + dbg_decouple("fpa2bv_add_unpack_b_sig", b_sig); + dbg_decouple("fpa2bv_add_unpack_b_exp", b_exp); + + expr_ref swap_cond(m); + swap_cond = m_bv_util.mk_sle(a_exp, b_exp); + + expr_ref c_sgn(m), c_sig(m), c_exp(m), d_sgn(m), d_sig(m), d_exp(m); + m_simp.mk_ite(swap_cond, b_sgn, a_sgn, c_sgn); + m_simp.mk_ite(swap_cond, b_sig, a_sig, c_sig); // has sbits + m_simp.mk_ite(swap_cond, b_exp, a_exp, c_exp); // has ebits + m_simp.mk_ite(swap_cond, a_sgn, b_sgn, d_sgn); + m_simp.mk_ite(swap_cond, a_sig, b_sig, d_sig); // has sbits + m_simp.mk_ite(swap_cond, a_exp, b_exp, d_exp); // has ebits + + expr_ref res_sgn(m), res_sig(m), res_exp(m); + add_core(sbits, ebits, rm, + c_sgn, c_sig, c_exp, d_sgn, d_sig, d_exp, + res_sgn, res_sig, res_exp); + + //Add the fixed zeroes here...? + expr_ref sbits_zero(m), ebits_zero(m); + // std::cout<<"res_sgn: "<1) + // //Exponent = 1 bit for bias, fixed bits, actual exponent bits + // res_exp=m_bv_util.mk_concat(m_bv_util.mk_extract(ebits+1, ebits-1, res_exp), + // m_bv_util.mk_concat(m_bv_util.mk_numeral(0,ezeroes), + // m_bv_util.mk_extract(ebits - 2 - ezeroes, 0 ,res_exp))); + // if(sones>1) + // res_sig=m_bv_util.mk_concat(m_bv_util.mk_extract(sbits+3,sones+4,res_sig), + // m_bv_util.mk_concat(m_bv_util.mk_numeral(0,sones), + // m_bv_util.mk_extract(3,0,res_sig))); + // + // std::cout<<"res_sgn': "<get_range(), rm, res_sgn, res_sig, res_exp, rounded); + + + mk_ite(is_zero_sig, zero_case, rounded, v7);*/ + + + + expr_ref rounded(m);//, fixed(m); + round(f->get_range(), rm, res_sgn, res_sig, res_exp, rounded); + + fix_bits(prec, rounded, sbits,ebits); + mk_ite(is_zero_sig, zero_case, rounded, v7); + + // signed sones=((sbits-3)*(MAX_PRECISION - prec +0.0)/MAX_PRECISION);//3 bits are minimum for the significand + // unsigned ezeroes=((ebits-2)*(MAX_PRECISION - prec+0.0)/MAX_PRECISION);//2 bits are minimum for the exponent + // expr_ref fix_sig(m), fix_exp(m), fix_sgn(m), rnd_sig(m), rnd_exp(m), rnd_sgn(m), rnd_lz(m); + // expr * sgn, *sig, *expn; + // split( rounded.get(), sgn,sig,expn); + // + // + // if(ezeroes>1) + // //Exponent = 1 bit for bias, fixed bits, actual exponent bits + // fix_exp=m_bv_util.mk_concat(m_bv_util.mk_extract(ebits-1, ebits-1, expn), + // m_bv_util.mk_concat(m_bv_util.mk_numeral(0,ezeroes), + // m_bv_util.mk_extract(ebits - 2 - ezeroes, 0 , expn))); + // if(sones>1) + // fix_sig=m_bv_util.mk_concat(m_bv_util.mk_extract(sbits-2,sones,sig), + // m_bv_util.mk_numeral(0,sones)); + // + // mk_triple(sgn, fix_sig, fix_exp, fixed); + // SASSERT(is_well_sorted(m, fixed)); + //mk_ite(is_zero_sig, zero_case, rounded, v7); + + + + + mk_ite(c6, v6, v7, result); + mk_ite(c5, v5, result, result); + mk_ite(c4, v4, result, result); + mk_ite(c3, v3, result, result); + mk_ite(c2, v2, result, result); + mk_ite(c1, v1, result, result); + + SASSERT(is_well_sorted(m, result)); + + TRACE("fpa2bv_add", tout << "ADD = " << mk_ismt2_pp(result, m) << std::endl; ); + } + break; + } + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_sub(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + SASSERT(num == 3); + expr_ref t(m); + fpa2bv_converter::mk_neg(f, 1, &args[2], t); + expr * nargs[3] = { args[0], args[1], t }; + + switch (m_mode) { + case FPAA_PRECISE: + fpa2bv_converter::mk_add(f, 3, nargs, result); + break; + case FPAA_FIXBITS: // Call the add with prec + case FPAA_SMALL_FLOATS: + fpa2bv_converter_prec::mk_add(f, prec, 3, nargs, result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_uminus(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_PRECISE: + case FPAA_SMALL_FLOATS: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_neg(f,num,args,result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_mul(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_PRECISE: + fpa2bv_converter::mk_mul(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + expr_ref small_op(m); + fpa2bv_converter::mk_mul(small_fd, num, small_args.c_ptr(), small_op); + mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_mul", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + case FPAA_FIXBITS: // for now, encode fully. + { SASSERT(num == 3); + + expr_ref rm(m), x(m), y(m); + rm = args[0]; + x = args[1]; + y = args[2]; + + expr_ref nan(m), nzero(m), pzero(m), ninf(m), pinf(m); + mk_nan(f, nan); + mk_nzero(f, nzero); + mk_pzero(f, pzero); + mk_ninf(f, ninf); + mk_pinf(f, pinf); + + expr_ref x_is_nan(m), x_is_zero(m), x_is_pos(m), x_is_inf(m); + expr_ref y_is_nan(m), y_is_zero(m), y_is_pos(m), y_is_inf(m); + mk_is_nan(x, x_is_nan); + mk_is_zero(x, x_is_zero); + mk_is_pos(x, x_is_pos); + mk_is_inf(x, x_is_inf); + mk_is_nan(y, y_is_nan); + mk_is_zero(y, y_is_zero); + mk_is_pos(y, y_is_pos); + mk_is_inf(y, y_is_inf); + + dbg_decouple("fpa2bv_mul_x_is_nan", x_is_nan); + dbg_decouple("fpa2bv_mul_x_is_zero", x_is_zero); + dbg_decouple("fpa2bv_mul_x_is_pos", x_is_pos); + dbg_decouple("fpa2bv_mul_x_is_inf", x_is_inf); + dbg_decouple("fpa2bv_mul_y_is_nan", y_is_nan); + dbg_decouple("fpa2bv_mul_y_is_zero", y_is_zero); + dbg_decouple("fpa2bv_mul_y_is_pos", y_is_pos); + dbg_decouple("fpa2bv_mul_y_is_inf", y_is_inf); + + expr_ref c1(m), c2(m), c3(m), c4(m), c5(m), c6(m); + expr_ref v1(m), v2(m), v3(m), v4(m), v5(m), v6(m), v7(m); + + // (x is NaN) || (y is NaN) -> NaN + m_simp.mk_or(x_is_nan, y_is_nan, c1); + v1 = nan; + + // (x is +oo) -> if (y is 0) then NaN else inf with y's sign. + mk_is_pinf(x, c2); + expr_ref y_sgn_inf(m); + mk_ite(y_is_pos, pinf, ninf, y_sgn_inf); + mk_ite(y_is_zero, nan, y_sgn_inf, v2); + + // (y is +oo) -> if (x is 0) then NaN else inf with x's sign. + mk_is_pinf(y, c3); + expr_ref x_sgn_inf(m); + mk_ite(x_is_pos, pinf, ninf, x_sgn_inf); + mk_ite(x_is_zero, nan, x_sgn_inf, v3); + + // (x is -oo) -> if (y is 0) then NaN else inf with -y's sign. + mk_is_ninf(x, c4); + expr_ref neg_y_sgn_inf(m); + mk_ite(y_is_pos, ninf, pinf, neg_y_sgn_inf); + mk_ite(y_is_zero, nan, neg_y_sgn_inf, v4); + + // (y is -oo) -> if (x is 0) then NaN else inf with -x's sign. + mk_is_ninf(y, c5); + expr_ref neg_x_sgn_inf(m); + mk_ite(x_is_pos, ninf, pinf, neg_x_sgn_inf); + mk_ite(x_is_zero, nan, neg_x_sgn_inf, v5); + + // (x is 0) || (y is 0) -> x but with sign = x.sign ^ y.sign + m_simp.mk_or(x_is_zero, y_is_zero, c6); + expr_ref sign_xor(m); + m_simp.mk_xor(x_is_pos, y_is_pos, sign_xor); + mk_ite(sign_xor, nzero, pzero, v6); + + // else comes the actual multiplication. + unsigned ebits = m_util.get_ebits(f->get_range()); + unsigned sbits = m_util.get_sbits(f->get_range()); + SASSERT(ebits <= sbits); + + expr_ref a_sgn(m), a_sig(m), a_exp(m), a_lz(m), b_sgn(m), b_sig(m), b_exp(m), b_lz(m); + unpack(x, a_sgn, a_sig, a_exp, a_lz, true); + unpack(y, b_sgn, b_sig, b_exp, b_lz, true); + + dbg_decouple("fpa2bv_mul_a_sig", a_sig); + dbg_decouple("fpa2bv_mul_a_exp", a_exp); + dbg_decouple("fpa2bv_mul_b_sig", b_sig); + dbg_decouple("fpa2bv_mul_b_exp", b_exp); + + expr_ref a_lz_ext(m), b_lz_ext(m); + a_lz_ext = m_bv_util.mk_zero_extend(2, a_lz); + b_lz_ext = m_bv_util.mk_zero_extend(2, b_lz); + + dbg_decouple("fpa2bv_mul_lz_a", a_lz); + dbg_decouple("fpa2bv_mul_lz_b", b_lz); + + expr_ref a_sig_ext(m), b_sig_ext(m); + a_sig_ext = m_bv_util.mk_zero_extend(sbits, a_sig); + b_sig_ext = m_bv_util.mk_zero_extend(sbits, b_sig); + + expr_ref a_exp_ext(m), b_exp_ext(m); + a_exp_ext = m_bv_util.mk_sign_extend(2, a_exp); + b_exp_ext = m_bv_util.mk_sign_extend(2, b_exp); + + expr_ref res_sgn(m), res_sig(m), res_exp(m); + expr * signs[2] = { a_sgn, b_sgn }; + res_sgn = m_bv_util.mk_bv_xor(2, signs); + + dbg_decouple("fpa2bv_mul_res_sgn", res_sgn); + + res_exp = m_bv_util.mk_bv_add( + m_bv_util.mk_bv_sub(a_exp_ext, a_lz_ext), + m_bv_util.mk_bv_sub(b_exp_ext, b_lz_ext)); + + expr_ref product(m); + product = m_bv_util.mk_bv_mul(a_sig_ext, b_sig_ext); + + dbg_decouple("fpa2bv_mul_product", product); + + SASSERT(m_bv_util.get_bv_size(product) == 2*sbits); + + expr_ref h_p(m), l_p(m), rbits(m); + h_p = m_bv_util.mk_extract(2*sbits-1, sbits, product); + l_p = m_bv_util.mk_extract(sbits-1, 0, product); + + if (sbits >= 4) { + expr_ref sticky(m); + sticky = m.mk_app(m_bv_util.get_fid(), OP_BREDOR, m_bv_util.mk_extract(sbits-4, 0, product)); + rbits = m_bv_util.mk_concat(m_bv_util.mk_extract(sbits-1, sbits-3, product), sticky); + } + else + rbits = m_bv_util.mk_concat(l_p, m_bv_util.mk_numeral(0, 4 - sbits)); + + SASSERT(m_bv_util.get_bv_size(rbits) == 4); + res_sig = m_bv_util.mk_concat(h_p, rbits); + + //expr_ref rounded(m); + round(f->get_range(), rm, res_sgn, res_sig, res_exp, v7); + + //AZ:the only difference to the original + fix_bits(prec, v7, sbits, ebits); + + // And finally, we tie them together. + mk_ite(c6, v6, v7, result); + mk_ite(c5, v5, result, result); + mk_ite(c4, v4, result, result); + mk_ite(c3, v3, result, result); + mk_ite(c2, v2, result, result); + mk_ite(c1, v1, result, result); + + SASSERT(is_well_sorted(m, result)); + + TRACE("fpa2bv_mul", tout << "MUL = " << mk_ismt2_pp(result, m) << std::endl; ); + } + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_div(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + expr_ref small_op(m); + fpa2bv_converter::mk_div(small_fd, num, small_args.c_ptr(), small_op); + mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_div", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + case FPAA_PRECISE: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_div(f,num,args,result); + break; + + { + SASSERT(num == 3); + + expr_ref rm(m), x(m), y(m); + rm = args[0]; + x = args[1]; + y = args[2]; + + expr_ref nan(m), nzero(m), pzero(m), ninf(m), pinf(m); + mk_nan(f, nan); + mk_nzero(f, nzero); + mk_pzero(f, pzero); + mk_ninf(f, ninf); + mk_pinf(f, pinf); + + expr_ref x_is_nan(m), x_is_zero(m), x_is_pos(m), x_is_inf(m); + expr_ref y_is_nan(m), y_is_zero(m), y_is_pos(m), y_is_inf(m); + mk_is_nan(x, x_is_nan); + mk_is_zero(x, x_is_zero); + mk_is_pos(x, x_is_pos); + mk_is_inf(x, x_is_inf); + mk_is_nan(y, y_is_nan); + mk_is_zero(y, y_is_zero); + mk_is_pos(y, y_is_pos); + mk_is_inf(y, y_is_inf); + + dbg_decouple("fpa2bv_div_x_is_nan", x_is_nan); + dbg_decouple("fpa2bv_div_x_is_zero", x_is_zero); + dbg_decouple("fpa2bv_div_x_is_pos", x_is_pos); + dbg_decouple("fpa2bv_div_x_is_inf", x_is_inf); + dbg_decouple("fpa2bv_div_y_is_nan", y_is_nan); + dbg_decouple("fpa2bv_div_y_is_zero", y_is_zero); + dbg_decouple("fpa2bv_div_y_is_pos", y_is_pos); + dbg_decouple("fpa2bv_div_y_is_inf", y_is_inf); + + expr_ref c1(m), c2(m), c3(m), c4(m), c5(m), c6(m), c7(m); + expr_ref v1(m), v2(m), v3(m), v4(m), v5(m), v6(m), v7(m), v8(m); + + // (x is NaN) || (y is NaN) -> NaN + m_simp.mk_or(x_is_nan, y_is_nan, c1); + v1 = nan; + + // (x is +oo) -> if (y is oo) then NaN else inf with y's sign. + mk_is_pinf(x, c2); + expr_ref y_sgn_inf(m); + mk_ite(y_is_pos, pinf, ninf, y_sgn_inf); + mk_ite(y_is_inf, nan, y_sgn_inf, v2); + + // (y is +oo) -> if (x is oo) then NaN else 0 with sign x.sgn ^ y.sgn + mk_is_pinf(y, c3); + expr_ref xy_zero(m), signs_xor(m); + m_simp.mk_xor(x_is_pos, y_is_pos, signs_xor); + mk_ite(signs_xor, nzero, pzero, xy_zero); + mk_ite(x_is_inf, nan, xy_zero, v3); + + // (x is -oo) -> if (y is oo) then NaN else inf with -y's sign. + mk_is_ninf(x, c4); + expr_ref neg_y_sgn_inf(m); + mk_ite(y_is_pos, ninf, pinf, neg_y_sgn_inf); + mk_ite(y_is_inf, nan, neg_y_sgn_inf, v4); + + // (y is -oo) -> if (x is oo) then NaN else 0 with sign x.sgn ^ y.sgn + mk_is_ninf(y, c5); + mk_ite(x_is_inf, nan, xy_zero, v5); + + // (y is 0) -> if (x is 0) then NaN else inf with xor sign. + c6 = y_is_zero; + expr_ref sgn_inf(m); + mk_ite(signs_xor, ninf, pinf, sgn_inf); + mk_ite(x_is_zero, nan, sgn_inf, v6); + + // (x is 0) -> result is zero with sgn = x.sgn^y.sgn + // This is a special case to avoid problems with the unpacking of zero. + c7 = x_is_zero; + mk_ite(signs_xor, nzero, pzero, v7); + + // else comes the actual division. + unsigned ebits = m_util.get_ebits(f->get_range()); + unsigned sbits = m_util.get_sbits(f->get_range()); + SASSERT(ebits <= sbits); + + expr_ref a_sgn(m), a_sig(m), a_exp(m), a_lz(m), b_sgn(m), b_sig(m), b_exp(m), b_lz(m); + unpack(x, a_sgn, a_sig, a_exp, a_lz, true); + unpack(y, b_sgn, b_sig, b_exp, b_lz, true); + + unsigned extra_bits = sbits+2; + expr_ref a_sig_ext(m), b_sig_ext(m); + a_sig_ext = m_bv_util.mk_concat(a_sig, m_bv_util.mk_numeral(0, sbits + extra_bits)); + b_sig_ext = m_bv_util.mk_zero_extend(sbits + extra_bits, b_sig); + + expr_ref a_exp_ext(m), b_exp_ext(m); + a_exp_ext = m_bv_util.mk_sign_extend(2, a_exp); + b_exp_ext = m_bv_util.mk_sign_extend(2, b_exp); + + expr_ref res_sgn(m), res_sig(m), res_exp(m); + expr * signs[2] = { a_sgn, b_sgn }; + res_sgn = m_bv_util.mk_bv_xor(2, signs); + + expr_ref a_lz_ext(m), b_lz_ext(m); + a_lz_ext = m_bv_util.mk_zero_extend(2, a_lz); + b_lz_ext = m_bv_util.mk_zero_extend(2, b_lz); + + res_exp = m_bv_util.mk_bv_sub( + m_bv_util.mk_bv_sub(a_exp_ext, a_lz_ext), + m_bv_util.mk_bv_sub(b_exp_ext, b_lz_ext)); + + expr_ref quotient(m); + quotient = m.mk_app(m_bv_util.get_fid(), OP_BUDIV, a_sig_ext, b_sig_ext); + + dbg_decouple("fpa2bv_div_quotient", quotient); + + SASSERT(m_bv_util.get_bv_size(quotient) == (sbits + sbits + extra_bits)); + + expr_ref sticky(m); + sticky = m.mk_app(m_bv_util.get_fid(), OP_BREDOR, m_bv_util.mk_extract(extra_bits-2, 0, quotient)); + res_sig = m_bv_util.mk_concat(m_bv_util.mk_extract(extra_bits+sbits+1, extra_bits-1, quotient), sticky); + + SASSERT(m_bv_util.get_bv_size(res_sig) == (sbits + 4)); + + //expr_ref rounded(m);//AZ + round(f->get_range(), rm, res_sgn, res_sig, res_exp, v8); + + fix_bits(prec, v8,sbits,ebits);//AZ + + // And finally, we tie them together. + mk_ite(c7, v7, v8, result); + mk_ite(c6, v6, result, result); + mk_ite(c5, v5, result, result); + mk_ite(c4, v4, result, result); + mk_ite(c3, v3, result, result); + mk_ite(c2, v2, result, result); + mk_ite(c1, v1, result, result); + + SASSERT(is_well_sorted(m, result)); + + TRACE("fpa2bv_div", tout << "DIV = " << mk_ismt2_pp(result, m) << std::endl; ); + } + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_remainder(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + expr_ref small_op(m); + fpa2bv_converter::mk_rem(small_fd, num, small_args.c_ptr(), small_op); + mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_remainder", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + case FPAA_PRECISE: + fpa2bv_converter::mk_rem(f,num,args,result); + break; + case FPAA_FIXBITS: // for now, encode fully. + { + SASSERT(num == 2); + + // Remainder is always exact, so there is no rounding mode. + expr_ref x(m), y(m); + x = args[0]; + y = args[1]; + + expr_ref nan(m), nzero(m), pzero(m), ninf(m), pinf(m); + mk_nan(f, nan); + mk_nzero(f, nzero); + mk_pzero(f, pzero); + mk_ninf(f, ninf); + mk_pinf(f, pinf); + + expr_ref x_is_nan(m), x_is_zero(m), x_is_pos(m), x_is_inf(m); + expr_ref y_is_nan(m), y_is_zero(m), y_is_pos(m), y_is_inf(m); + mk_is_nan(x, x_is_nan); + mk_is_zero(x, x_is_zero); + mk_is_pos(x, x_is_pos); + mk_is_inf(x, x_is_inf); + mk_is_nan(y, y_is_nan); + mk_is_zero(y, y_is_zero); + mk_is_pos(y, y_is_pos); + mk_is_inf(y, y_is_inf); + + dbg_decouple("fpa2bv_rem_x_is_nan", x_is_nan); + dbg_decouple("fpa2bv_rem_x_is_zero", x_is_zero); + dbg_decouple("fpa2bv_rem_x_is_pos", x_is_pos); + dbg_decouple("fpa2bv_rem_x_is_inf", x_is_inf); + dbg_decouple("fpa2bv_rem_y_is_nan", y_is_nan); + dbg_decouple("fpa2bv_rem_y_is_zero", y_is_zero); + dbg_decouple("fpa2bv_rem_y_is_pos", y_is_pos); + dbg_decouple("fpa2bv_rem_y_is_inf", y_is_inf); + + expr_ref c1(m), c2(m), c3(m), c4(m), c5(m), c6(m); + expr_ref v1(m), v2(m), v3(m), v4(m), v5(m), v6(m), v7(m); + + // (x is NaN) || (y is NaN) -> NaN + m_simp.mk_or(x_is_nan, y_is_nan, c1); + v1 = nan; + + // (x is +-oo) -> NaN + c2 = x_is_inf; + v2 = nan; + + // (y is +-oo) -> x + c3 = y_is_inf; + v3 = x; + + // (x is 0) -> x + c4 = x_is_zero; + v4 = pzero; + + // (y is 0) -> NaN. + c5 = y_is_zero; + v5 = nan; + + // else the actual remainder. + unsigned ebits = m_util.get_ebits(f->get_range()); + unsigned sbits = m_util.get_sbits(f->get_range()); + + expr_ref a_sgn(m), a_sig(m), a_exp(m), a_lz(m); + expr_ref b_sgn(m), b_sig(m), b_exp(m), b_lz(m); + unpack(x, a_sgn, a_sig, a_exp, a_lz, true); + unpack(y, b_sgn, b_sig, b_exp, b_lz, true); + + BVSLT(a_exp, b_exp, c6); + v6 = x; + + // max. exponent difference is (2^ebits) - 3 + const mpz & two_to_ebits = fu().fm().m_powers2(ebits); + mpz max_exp_diff; + m_mpz_manager.sub(two_to_ebits, 3, max_exp_diff); + SASSERT(m_mpz_manager.is_int64(max_exp_diff)); + SASSERT(m_mpz_manager.get_uint64(max_exp_diff) <= UINT_MAX); + + unsigned int max_exp_diff_ui = (unsigned int)m_mpz_manager.get_uint64(max_exp_diff); + m_mpz_manager.del(max_exp_diff); + + expr_ref exp_diff(m); + exp_diff = m_bv_util.mk_bv_sub(a_exp, b_exp); + dbg_decouple("fpa2bv_rem_exp_diff", exp_diff); + + // CMW: This creates _huge_ bit-vectors, which is potentially sub-optimal, + // but calculating this via rem = x - y * nearest(x/y) creates huge circuits. + expr_ref huge_sig(m), shifted_sig(m), huge_rem(m); + huge_sig = m_bv_util.mk_zero_extend(max_exp_diff_ui, a_sig); + shifted_sig = m_bv_util.mk_bv_shl(huge_sig, m_bv_util.mk_zero_extend(max_exp_diff_ui + sbits - ebits, exp_diff)); + huge_rem = m_bv_util.mk_bv_urem(shifted_sig, m_bv_util.mk_zero_extend(max_exp_diff_ui, b_sig)); + dbg_decouple("fpa2bv_rem_huge_rem", huge_rem); + + expr_ref res_sgn(m), res_sig(m), res_exp(m); + res_sgn = a_sgn; + res_sig = m_bv_util.mk_concat(m_bv_util.mk_extract(sbits, 0, huge_rem), + m_bv_util.mk_numeral(0, 3)); + res_exp = m_bv_util.mk_sign_extend(2, b_exp); + + expr_ref rm(m); + rm = m_bv_util.mk_numeral(BV_RM_TIES_TO_EVEN, 3); + + //expr_ref rounded(m); + round(f->get_range(), rm, res_sgn, res_sig, res_exp, v7); + + fix_bits(prec, v7,sbits, ebits); + + // And finally, we tie them together. + mk_ite(c6, v6, v7, result); + mk_ite(c5, v5, result, result); + mk_ite(c4, v4, result, result); + mk_ite(c3, v3, result, result); + mk_ite(c2, v2, result, result); + mk_ite(c1, v1, result, result); + + SASSERT(is_well_sorted(m, result)); + + TRACE("fpa2bv_rem", tout << "REM = " << mk_ismt2_pp(result, m) << std::endl; ); + } + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_abs(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + //This doesn't need approximation in it's current form + switch (m_mode) { + case FPAA_PRECISE: + case FPAA_SMALL_FLOATS: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_abs(f,num,args,result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_min(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_PRECISE: + case FPAA_SMALL_FLOATS: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_min(f,num,args,result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_max(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_PRECISE: + case FPAA_SMALL_FLOATS: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_max(f,num,args,result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_fusedma(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + expr_ref small_op(m); + fpa2bv_converter::mk_fma(small_fd, num, small_args.c_ptr(), small_op); + mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_fma", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + case FPAA_PRECISE: + fpa2bv_converter::mk_fma(f,num,args,result); + break; + case FPAA_FIXBITS: + { + SASSERT(num == 4); + + // fusedma means (x * y) + z + expr_ref rm(m), x(m), y(m), z(m); + rm = args[0]; + x = args[1]; + y = args[2]; + z = args[3]; + + expr_ref nan(m), nzero(m), pzero(m), ninf(m), pinf(m); + mk_nan(f, nan); + mk_nzero(f, nzero); + mk_pzero(f, pzero); + mk_ninf(f, ninf); + mk_pinf(f, pinf); + + expr_ref x_is_nan(m), x_is_zero(m), x_is_pos(m), x_is_neg(m), x_is_inf(m); + expr_ref y_is_nan(m), y_is_zero(m), y_is_pos(m), y_is_neg(m), y_is_inf(m); + expr_ref z_is_nan(m), z_is_zero(m), z_is_pos(m), z_is_neg(m), z_is_inf(m); + mk_is_nan(x, x_is_nan); + mk_is_zero(x, x_is_zero); + mk_is_pos(x, x_is_pos); + mk_is_neg(x, x_is_neg); + mk_is_inf(x, x_is_inf); + mk_is_nan(y, y_is_nan); + mk_is_zero(y, y_is_zero); + mk_is_pos(y, y_is_pos); + mk_is_neg(y, y_is_neg); + mk_is_inf(y, y_is_inf); + mk_is_nan(z, z_is_nan); + mk_is_zero(z, z_is_zero); + mk_is_pos(z, z_is_pos); + mk_is_neg(z, z_is_neg); + mk_is_inf(z, z_is_inf); + + expr_ref rm_is_to_neg(m); + mk_is_rm(rm, BV_RM_TO_NEGATIVE, rm_is_to_neg); + + dbg_decouple("fpa2bv_fma_x_is_nan", x_is_nan); + dbg_decouple("fpa2bv_fma_x_is_zero", x_is_zero); + dbg_decouple("fpa2bv_fma_x_is_pos", x_is_pos); + dbg_decouple("fpa2bv_fma_x_is_inf", x_is_inf); + dbg_decouple("fpa2bv_fma_y_is_nan", y_is_nan); + dbg_decouple("fpa2bv_fma_y_is_zero", y_is_zero); + dbg_decouple("fpa2bv_fma_y_is_pos", y_is_pos); + dbg_decouple("fpa2bv_fma_y_is_inf", y_is_inf); + dbg_decouple("fpa2bv_fma_z_is_nan", z_is_nan); + dbg_decouple("fpa2bv_fma_z_is_zero", z_is_zero); + dbg_decouple("fpa2bv_fma_z_is_pos", z_is_pos); + dbg_decouple("fpa2bv_fma_z_is_inf", z_is_inf); + + expr_ref c1(m), c2(m), c3(m), c4(m), c5(m), c6(m), c7(m); + expr_ref v1(m), v2(m), v3(m), v4(m), v5(m), v6(m), v7(m), v8(m); + + expr_ref inf_xor(m), inf_cond(m); + m_simp.mk_xor(x_is_neg, y_is_neg, inf_xor); + m_simp.mk_xor(inf_xor, z_is_neg, inf_xor); + m_simp.mk_and(z_is_inf, inf_xor, inf_cond); + + // (x is NaN) || (y is NaN) || (z is Nan) -> NaN + m_simp.mk_or(x_is_nan, y_is_nan, z_is_nan, c1); + v1 = nan; + + // (x is +oo) -> if (y is 0) then NaN else inf with y's sign. + mk_is_pinf(x, c2); + expr_ref y_sgn_inf(m), inf_or(m); + mk_ite(y_is_pos, pinf, ninf, y_sgn_inf); + m_simp.mk_or(y_is_zero, inf_cond, inf_or); + mk_ite(inf_or, nan, y_sgn_inf, v2); + + // (y is +oo) -> if (x is 0) then NaN else inf with x's sign. + mk_is_pinf(y, c3); + expr_ref x_sgn_inf(m); + mk_ite(x_is_pos, pinf, ninf, x_sgn_inf); + m_simp.mk_or(x_is_zero, inf_cond, inf_or); + mk_ite(inf_or, nan, x_sgn_inf, v3); + + // (x is -oo) -> if (y is 0) then NaN else inf with -y's sign. + mk_is_ninf(x, c4); + expr_ref neg_y_sgn_inf(m); + mk_ite(y_is_pos, ninf, pinf, neg_y_sgn_inf); + m_simp.mk_or(y_is_zero, inf_cond, inf_or); + mk_ite(inf_or, nan, neg_y_sgn_inf, v4); + + // (y is -oo) -> if (x is 0) then NaN else inf with -x's sign. + mk_is_ninf(y, c5); + expr_ref neg_x_sgn_inf(m); + mk_ite(x_is_pos, ninf, pinf, neg_x_sgn_inf); + m_simp.mk_or(x_is_zero, inf_cond, inf_or); + mk_ite(inf_or, nan, neg_x_sgn_inf, v5); + + // z is +-INF -> z. + mk_is_inf(z, c6); + v6 = z; + + // (x is 0) || (y is 0) -> z + m_simp.mk_or(x_is_zero, y_is_zero, c7); + expr_ref ite_c(m); + m_simp.mk_and(z_is_zero, m.mk_not(rm_is_to_neg), ite_c); + mk_ite(ite_c, pzero, z, v7); + + + // else comes the fused multiplication. + unsigned ebits = m_util.get_ebits(f->get_range()); + unsigned sbits = m_util.get_sbits(f->get_range()); + SASSERT(ebits <= sbits); + + expr_ref a_sgn(m), a_sig(m), a_exp(m), a_lz(m); + expr_ref b_sgn(m), b_sig(m), b_exp(m), b_lz(m); + expr_ref c_sgn(m), c_sig(m), c_exp(m), c_lz(m); + unpack(x, a_sgn, a_sig, a_exp, a_lz, true); + unpack(y, b_sgn, b_sig, b_exp, b_lz, true); + unpack(z, c_sgn, c_sig, c_exp, c_lz, true); + + expr_ref a_lz_ext(m), b_lz_ext(m), c_lz_ext(m); + a_lz_ext = m_bv_util.mk_zero_extend(2, a_lz); + b_lz_ext = m_bv_util.mk_zero_extend(2, b_lz); + c_lz_ext = m_bv_util.mk_zero_extend(2, c_lz); + + expr_ref a_sig_ext(m), b_sig_ext(m); + a_sig_ext = m_bv_util.mk_zero_extend(sbits, a_sig); + b_sig_ext = m_bv_util.mk_zero_extend(sbits, b_sig); + + expr_ref a_exp_ext(m), b_exp_ext(m), c_exp_ext(m); + a_exp_ext = m_bv_util.mk_sign_extend(2, a_exp); + b_exp_ext = m_bv_util.mk_sign_extend(2, b_exp); + c_exp_ext = m_bv_util.mk_sign_extend(2, c_exp); + + dbg_decouple("fpa2bv_fma_a_sig", a_sig_ext); + dbg_decouple("fpa2bv_fma_b_sig", b_sig_ext); + dbg_decouple("fpa2bv_fma_c_sig", c_sig); + dbg_decouple("fpa2bv_fma_a_exp", a_exp_ext); + dbg_decouple("fpa2bv_fma_b_exp", b_exp_ext); + dbg_decouple("fpa2bv_fma_c_exp", c_exp_ext); + dbg_decouple("fpa2bv_fma_a_lz", a_lz_ext); + dbg_decouple("fpa2bv_fma_b_lz", b_lz_ext); + dbg_decouple("fpa2bv_fma_c_lz", c_lz_ext); + + expr_ref mul_sgn(m), mul_sig(m), mul_exp(m); + expr * signs[2] = { a_sgn, b_sgn }; + + mul_sgn = m_bv_util.mk_bv_xor(2, signs); + dbg_decouple("fpa2bv_fma_mul_sgn", mul_sgn); + + mul_exp = m_bv_util.mk_bv_add(m_bv_util.mk_bv_sub(a_exp_ext, a_lz_ext), + m_bv_util.mk_bv_sub(b_exp_ext, b_lz_ext)); + dbg_decouple("fpa2bv_fma_mul_exp", mul_exp); + + mul_sig = m_bv_util.mk_bv_mul(a_sig_ext, b_sig_ext); + dbg_decouple("fpa2bv_fma_mul_sig", mul_sig); + + SASSERT(m_bv_util.get_bv_size(mul_sig) == 2*sbits); + SASSERT(m_bv_util.get_bv_size(mul_exp) == ebits + 2); + + // The product has the form [-1][0].[2*sbits - 2]. + + // Extend c + c_sig = m_bv_util.mk_zero_extend(1, m_bv_util.mk_concat(c_sig, m_bv_util.mk_numeral(0, sbits-1))); + c_exp_ext = m_bv_util.mk_bv_sub(c_exp_ext, c_lz_ext); + + SASSERT(m_bv_util.get_bv_size(mul_sig) == 2 * sbits); + SASSERT(m_bv_util.get_bv_size(c_sig) == 2 * sbits); + + expr_ref swap_cond(m); + swap_cond = m_bv_util.mk_sle(mul_exp, c_exp_ext); + SASSERT(is_well_sorted(m, swap_cond)); + dbg_decouple("fpa2bv_fma_swap_cond", swap_cond); + + expr_ref e_sgn(m), e_sig(m), e_exp(m), f_sgn(m), f_sig(m), f_exp(m); + m_simp.mk_ite(swap_cond, c_sgn, mul_sgn, e_sgn); + m_simp.mk_ite(swap_cond, c_sig, mul_sig, e_sig); // has 2 * sbits + m_simp.mk_ite(swap_cond, c_exp_ext, mul_exp, e_exp); // has ebits + 2 + m_simp.mk_ite(swap_cond, mul_sgn, c_sgn, f_sgn); + m_simp.mk_ite(swap_cond, mul_sig, c_sig, f_sig); // has 2 * sbits + m_simp.mk_ite(swap_cond, mul_exp, c_exp_ext, f_exp); // has ebits + 2 + + SASSERT(is_well_sorted(m, e_sgn)); + SASSERT(is_well_sorted(m, e_sig)); + SASSERT(is_well_sorted(m, e_exp)); + SASSERT(is_well_sorted(m, f_sgn)); + SASSERT(is_well_sorted(m, f_sig)); + SASSERT(is_well_sorted(m, f_exp)); + + SASSERT(m_bv_util.get_bv_size(e_sig) == 2 * sbits); + SASSERT(m_bv_util.get_bv_size(f_sig) == 2 * sbits); + SASSERT(m_bv_util.get_bv_size(e_exp) == ebits + 2); + SASSERT(m_bv_util.get_bv_size(f_exp) == ebits + 2); + + expr_ref res_sgn(m), res_sig(m), res_exp(m); + + expr_ref exp_delta(m); + exp_delta = m_bv_util.mk_bv_sub(e_exp, f_exp); + dbg_decouple("fpa2bv_fma_add_exp_delta", exp_delta); + + // cap the delta + expr_ref cap(m), cap_le_delta(m); + cap = m_bv_util.mk_numeral(2*sbits, ebits+2); + cap_le_delta = m_bv_util.mk_ule(cap, exp_delta); + m_simp.mk_ite(cap_le_delta, cap, exp_delta, exp_delta); + SASSERT(m_bv_util.get_bv_size(exp_delta) == ebits+2); + SASSERT(is_well_sorted(m, exp_delta)); + dbg_decouple("fpa2bv_fma_add_exp_delta_capped", exp_delta); + + // Alignment shift with sticky bit computation. + expr_ref shifted_big(m), shifted_f_sig(m), sticky_raw(m); + shifted_big = m_bv_util.mk_bv_lshr( + m_bv_util.mk_concat(f_sig, m_bv_util.mk_numeral(0, sbits)), + m_bv_util.mk_zero_extend((3*sbits)-(ebits+2), exp_delta)); + shifted_f_sig = m_bv_util.mk_extract(3*sbits-1, sbits, shifted_big); + sticky_raw = m_bv_util.mk_extract(sbits-1, 0, shifted_big); + SASSERT(m_bv_util.get_bv_size(shifted_f_sig) == 2 * sbits); + SASSERT(is_well_sorted(m, shifted_f_sig)); + + expr_ref sticky(m); + sticky = m_bv_util.mk_zero_extend(2*sbits-1, m.mk_app(m_bv_util.get_fid(), OP_BREDOR, sticky_raw.get())); + SASSERT(is_well_sorted(m, sticky)); + dbg_decouple("fpa2bv_fma_f_sig_sticky_raw", sticky_raw); + dbg_decouple("fpa2bv_fma_f_sig_sticky", sticky); + + expr * or_args[2] = { shifted_f_sig, sticky }; + shifted_f_sig = m_bv_util.mk_bv_or(2, or_args); + SASSERT(is_well_sorted(m, shifted_f_sig)); + + // Significant addition. + // Two extra bits for catching the overflow. + e_sig = m_bv_util.mk_zero_extend(2, e_sig); + shifted_f_sig = m_bv_util.mk_zero_extend(2, shifted_f_sig); + + expr_ref eq_sgn(m); + m_simp.mk_eq(e_sgn, f_sgn, eq_sgn); + + SASSERT(m_bv_util.get_bv_size(e_sig) == 2*sbits + 2); + SASSERT(m_bv_util.get_bv_size(shifted_f_sig) == 2*sbits + 2); + + dbg_decouple("fpa2bv_fma_add_e_sig", e_sig); + dbg_decouple("fpa2bv_fma_add_shifted_f_sig", shifted_f_sig); + + expr_ref sum(m); + m_simp.mk_ite(eq_sgn, + m_bv_util.mk_bv_add(e_sig, shifted_f_sig), + m_bv_util.mk_bv_sub(e_sig, shifted_f_sig), + sum); + + SASSERT(is_well_sorted(m, sum)); + + dbg_decouple("fpa2bv_fma_add_sum", sum); + + expr_ref sign_bv(m), n_sum(m); + sign_bv = m_bv_util.mk_extract(2*sbits+1, 2*sbits+1, sum); + n_sum = m_bv_util.mk_bv_neg(sum); + + expr_ref res_sig_eq(m), sig_abs(m), one_1(m); + one_1 = m_bv_util.mk_numeral(1, 1); + m_simp.mk_eq(sign_bv, one_1, res_sig_eq); + m_simp.mk_ite(res_sig_eq, n_sum, sum, sig_abs); + dbg_decouple("fpa2bv_fma_add_sign_bv", sign_bv); + dbg_decouple("fpa2bv_fma_add_n_sum", n_sum); + dbg_decouple("fpa2bv_fma_add_sig_abs", sig_abs); + + res_exp = e_exp; + + // Result could overflow into 4.xxx ... + + family_id bvfid = m_bv_util.get_fid(); + expr_ref res_sgn_c1(m), res_sgn_c2(m), res_sgn_c3(m); + expr_ref not_e_sgn(m), not_f_sgn(m), not_sign_bv(m); + not_e_sgn = m_bv_util.mk_bv_not(e_sgn); + not_f_sgn = m_bv_util.mk_bv_not(f_sgn); + not_sign_bv = m_bv_util.mk_bv_not(sign_bv); + res_sgn_c1 = m.mk_app(bvfid, OP_BAND, not_e_sgn, e_sgn, sign_bv); + res_sgn_c2 = m.mk_app(bvfid, OP_BAND, e_sgn, not_f_sgn, not_sign_bv); + res_sgn_c3 = m.mk_app(bvfid, OP_BAND, e_sgn, f_sgn); + expr * res_sgn_or_args[3] = { res_sgn_c1, res_sgn_c2, res_sgn_c3 }; + res_sgn = m_bv_util.mk_bv_or(3, res_sgn_or_args); + + sticky_raw = m_bv_util.mk_extract(sbits-5, 0, sig_abs); + sticky = m_bv_util.mk_zero_extend(sbits+3, m.mk_app(bvfid, OP_BREDOR, sticky_raw.get())); + dbg_decouple("fpa2bv_fma_add_sum_sticky", sticky); + + expr * res_or_args[2] = { m_bv_util.mk_extract(2*sbits-1, sbits-4, sig_abs), sticky }; + res_sig = m_bv_util.mk_bv_or(2, res_or_args); + SASSERT(m_bv_util.get_bv_size(res_sig) == sbits+4); + + expr_ref is_zero_sig(m), nil_sbits4(m); + nil_sbits4 = m_bv_util.mk_numeral(0, sbits+4); + m_simp.mk_eq(res_sig, nil_sbits4, is_zero_sig); + SASSERT(is_well_sorted(m, is_zero_sig)); + + dbg_decouple("fpa2bv_fma_is_zero_sig", is_zero_sig); + + expr_ref zero_case(m); + mk_ite(rm_is_to_neg, nzero, pzero, zero_case); + + + //AZ: Should the zero case be constrained in some manner? + expr_ref rounded(m);//, fixed(m); + round(f->get_range(), rm, res_sgn, res_sig, res_exp, rounded); + + fix_bits(prec,rounded,sbits, ebits); + + mk_ite(is_zero_sig, zero_case, rounded, v8); + + // And finally, we tie them together. + mk_ite(c7, v7, v8, result); + mk_ite(c6, v6, result, result); + mk_ite(c5, v5, result, result); + mk_ite(c4, v4, result, result); + mk_ite(c3, v3, result, result); + mk_ite(c2, v2, result, result); + mk_ite(c1, v1, result, result); + + SASSERT(is_well_sorted(m, result)); + + TRACE("fpa2bv_fma_", tout << "FMA = " << mk_ismt2_pp(result, m) << std::endl; ); + } + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_sqrt(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + expr_ref small_op(m); + fpa2bv_converter::mk_sqrt(small_fd, num, small_args.c_ptr(), small_op); + mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_sqrt", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + case FPAA_PRECISE: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_sqrt(f,num,args,result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::mk_round_to_integral(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) { + switch (m_mode) { + case FPAA_SMALL_FLOATS: + { + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + mk_small_op(f, prec, num, args, small_fd, small_args); + expr_ref small_op(m); + fpa2bv_converter::mk_round_to_integral(small_fd, num, small_args.c_ptr(), small_op); + mk_cast_small_to_big(f, small_op, result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_r2i", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + case FPAA_PRECISE: + case FPAA_FIXBITS: // for now, encode fully. + fpa2bv_converter::mk_sqrt(f,num,args,result); + break; + default: UNREACHABLE(); break; + } +} + +void fpa2bv_converter_prec::establish_sort(unsigned num, expr * const * args, unsigned & ebits, unsigned & sbits) +{ + unsigned ne,ns; + //hardcoding for now + ebits = 3; + sbits = 3; + for(unsigned i=0;iget_decl()->get_range())) + { + ne = fu().get_ebits(s); + ns = fu().get_sbits(s); + ebits = (ne < ebits)?ebits:ne; + sbits = (ns < sbits)?sbits:ns; + } + } +} + +void fpa2bv_converter_prec::mk_float_eq(func_decl * f, unsigned num, expr * const * args, expr_ref & result) +{ + switch (m_mode) { + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_float_eq(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: + { + unsigned sbits, ebits; + + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + establish_sort(num, args, ebits, sbits); + mk_small_op(f, ebits, sbits, num, args, small_fd, small_args); + fpa2bv_converter::mk_float_eq(small_fd, num, small_args.c_ptr(), result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + } + +} + +void fpa2bv_converter_prec::mk_float_lt(func_decl * f, unsigned num, expr * const * args, expr_ref & result) +{ + switch (m_mode){ + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_float_lt(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: { + unsigned sbits, ebits; + + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + establish_sort(num, args, ebits, sbits); + mk_small_op(f, ebits, sbits, num, args, small_fd, small_args); + fpa2bv_converter::mk_float_lt(small_fd, num, small_args.c_ptr(), result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + } +} +void fpa2bv_converter_prec::mk_float_gt(func_decl * f, unsigned num, expr * const * args, expr_ref & result) +{ + switch (m_mode){ + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_float_gt(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: { + unsigned sbits, ebits; + + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + establish_sort(num, args, ebits, sbits); + mk_small_op(f, ebits, sbits, num, args, small_fd, small_args); + fpa2bv_converter::mk_float_gt(small_fd, num, small_args.c_ptr(), result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + } +} +void fpa2bv_converter_prec::mk_float_le(func_decl * f, unsigned num, expr * const * args, expr_ref & result) +{ + switch (m_mode){ + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_float_le(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: { + unsigned sbits, ebits; + + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + establish_sort(num, args, ebits, sbits); + mk_small_op(f, ebits, sbits, num, args, small_fd, small_args); + fpa2bv_converter::mk_float_le(small_fd, num, small_args.c_ptr(), result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + } +} +void fpa2bv_converter_prec::mk_float_ge(func_decl * f, unsigned num, expr * const * args, expr_ref & result) +{ + switch (m_mode){ + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_float_ge(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: { + unsigned sbits, ebits; + + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + establish_sort(num, args, ebits, sbits); + mk_small_op(f, ebits, sbits, num, args, small_fd, small_args); + fpa2bv_converter::mk_float_ge(small_fd, num, small_args.c_ptr(), result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + } +} +/* + +void fpa2bv_converter_prec::mk_is_zero(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result) +{ + switch (m_mode){ + case FPAA_PRECISE: + case FPAA_FIXBITS: + fpa2bv_converter::mk_float_eq(f,num,args,result); + break; + case FPAA_SMALL_FLOATS: { + unsigned sbits, ebits; + + func_decl_ref small_fd(m); + expr_ref_vector small_args(m); + establish_sort(num, args, ebits, sbits); + mk_small_op(f, ebits, sbits, num, args, small_fd, small_args); + fpa2bv_converter::mk_is_zero(small_fd, num, small_args.c_ptr(), result); + SASSERT(is_well_sorted(m, result)); + TRACE("fpa2bv_small_float_add", tout << mk_ismt2_pp(result, m) << std::endl; ); + break; + } + } +} +void fpa2bv_converter_prec::mk_is_nzero(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +void fpa2bv_converter_prec::mk_is_pzero(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +void fpa2bv_converter_prec::mk_is_sign_minus(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +void fpa2bv_converter_prec::mk_is_nan(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +void fpa2bv_converter_prec::mk_is_inf(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +void fpa2bv_converter_prec::mk_is_normal(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +void fpa2bv_converter_prec::mk_is_subnormal(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); +*/ + + + + + + diff --git a/src/tactic/fpa/fpa2bv_converter_prec.h b/src/tactic/fpa/fpa2bv_converter_prec.h new file mode 100644 index 00000000000..24631b1ff1e --- /dev/null +++ b/src/tactic/fpa/fpa2bv_converter_prec.h @@ -0,0 +1,103 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + fpa2bv_converter_prec.h + +Abstract: + + Conversion routines for Floating Point -> Bit-Vector + +Author: + + Christoph (cwinter) 2012-02-09 + +Notes: + +--*/ +#ifndef _FPA2BV_CONVERTER_PREC +#define _FPA2BV_CONVERTER_PREC + +#include"ast.h" +#include"obj_hashtable.h" +#include"ref_util.h" +#include"fpa_decl_plugin.h" +#include"bv_decl_plugin.h" +#include"model_converter.h" +#include"basic_simplifier_plugin.h" +#include"fpa2bv_converter.h" + +#define MAX_PRECISION 100 +#define MIN_PRECISION 0 + +class fpa2bv_prec_model_converter; + +enum fpa_approximation_mode { + FPAA_PRECISE, // Always use precise encoding + FPAA_FIXBITS, // Approximate by fixing some bits of the encoding + FPAA_SMALL_FLOATS // Approximate by using smaller floats +}; + +#define FPAA_DEFAULT_MODE FPAA_SMALL_FLOATS + +class fpa2bv_converter_prec : public fpa2bv_converter { + fpa_approximation_mode m_mode; + + void fix_bits(unsigned prec, expr_ref rounded, unsigned sbits, unsigned ebits);//expr_ref& fixed, + + void mk_small_op(func_decl * f, unsigned prec, unsigned num, expr * const * args, func_decl_ref & small_op, expr_ref_vector & cast_args); + void mk_small_op(func_decl * f, unsigned new_ebits, unsigned new_sbits, unsigned num, expr * const * args, func_decl_ref & small_op, expr_ref_vector & cast_args); + void mk_cast_small_to_big(func_decl * big_fd, expr * arg, expr_ref & result); + void mk_cast_small_to_big(unsigned sbits, unsigned ebits, expr * arg, expr_ref & result); + void match_sorts(expr * a, expr * b, expr_ref & n_a, expr_ref & n_b); + void establish_sort(unsigned num, expr * const * args, unsigned & ebits, unsigned & sbits); +public: + fpa2bv_converter_prec(ast_manager & m, fpa_approximation_mode mode); + + void mk_const(func_decl * f, unsigned prec, expr_ref & result); + + void mk_eq(expr * a, expr * b, expr_ref & result); + void mk_ite(expr * c, expr * t, expr * f, expr_ref & result); + + void mk_add(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_sub(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_uminus(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_mul(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_div(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_remainder(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_abs(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_min(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_max(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_fusedma(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_sqrt(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_round_to_integral(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + + void mk_float_eq(func_decl * f, unsigned num, expr * const * args, expr_ref & result); + void mk_float_lt(func_decl * f, unsigned num, expr * const * args, expr_ref & result); + void mk_float_gt(func_decl * f, unsigned num, expr * const * args, expr_ref & result); + void mk_float_le(func_decl * f, unsigned num, expr * const * args, expr_ref & result); + void mk_float_ge(func_decl * f, unsigned num, expr * const * args, expr_ref & result); + + /* + void mk_is_zero(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_nzero(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_pzero(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_sign_minus(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_nan(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_inf(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_normal(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + void mk_is_subnormal(func_decl * f, unsigned prec, unsigned num, expr * const * args, expr_ref & result); + */ + + + + void reset() { + dec_ref_map_key_values(m, m_const2bv); + dec_ref_map_key_values(m, m_rm_const2bv); + } +}; + + + +#endif diff --git a/src/tactic/fpa/fpa2bv_rewriter_prec.h b/src/tactic/fpa/fpa2bv_rewriter_prec.h new file mode 100644 index 00000000000..051790ac312 --- /dev/null +++ b/src/tactic/fpa/fpa2bv_rewriter_prec.h @@ -0,0 +1,261 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + fpa2bv_rewriter.h + +Abstract: + + Rewriter for converting FPA to BV + +Author: + + Christoph (cwinter) 2012-02-09 + +Notes: + +--*/ + +#ifndef _FPA2BV_REWRITER_H_ +#define _FPA2BV_REWRITER_H_ + +#include"cooperate.h" +#include"rewriter_def.h" +#include"bv_decl_plugin.h" +#include"fpa2bv_converter_prec.h" +#include"tactic_exception.h" +#include + +struct fpa2bv_rewriter_prec_cfg : public default_rewriter_cfg { + ast_manager & m_manager; + expr_ref_vector m_out; + fpa2bv_converter_prec & m_conv; + obj_map * cnst2prec_map; + + unsigned precision; + unsigned long long m_max_memory; + unsigned m_max_steps; + + ast_manager & m() const { return m_manager; } + + fpa2bv_rewriter_prec_cfg(ast_manager & m, fpa2bv_converter_prec & c, params_ref const & p): + m_manager(m), + m_out(m), + m_conv(c) { + updt_params(p); + // We need to make sure that the mananger has the BV plugin loaded. + symbol s_bv("bv"); + if (!m_manager.has_plugin(s_bv)) + m_manager.register_plugin(s_bv, alloc(bv_decl_plugin)); + } + + ~fpa2bv_rewriter_prec_cfg() { + } + + void cleanup_buffers() { + m_out.finalize(); + } + + unsigned get_precision(func_decl * f){ + if(cnst2prec_map->contains(f)) + return cnst2prec_map->find(f); + else return precision; + } + void set_precision(unsigned p) { precision=p; } + void set_mappings(obj_map * o2p) + { + this->cnst2prec_map=o2p; + } + + void updt_params(params_ref const & p) { + m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); + m_max_steps = p.get_uint("max_steps", UINT_MAX); + } + + bool max_steps_exceeded(unsigned num_steps) const { + cooperate("fpa2bv"); + return num_steps > m_max_steps; + } + + br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) { + TRACE("fpa2bv_rw", tout << "APP: " << f->get_name() << std::endl; ); + + if (num == 0 && f->get_family_id() == null_family_id && m_conv.is_float(f->get_range())) { + m_conv.mk_const(f, get_precision(f), result); + return BR_DONE; + } + + if (num == 0 && f->get_family_id() == null_family_id && m_conv.is_rm(f->get_range())) { + m_conv.mk_rm_const(f, result); + return BR_DONE; + } + + if (m().is_eq(f)) { + SASSERT(num == 2); + //SASSERT(m().get_sort(args[0]) == m().get_sort(args[1])); + sort * ds = f->get_domain()[0]; + if (m_conv.is_float(ds)) { + m_conv.mk_eq(args[0], args[1], result); + return BR_DONE; + } + else if (m_conv.is_rm(ds)) { + result = m().mk_eq(args[0], args[1]); + return BR_DONE; + } + return BR_FAILED; + } + + if (m().is_ite(f)) { + SASSERT(num == 3); + if (m_conv.is_float(args[1])) { + m_conv.mk_ite(args[0], args[1], args[2], result); + return BR_DONE; + } + return BR_FAILED; + } + + expr_ref newAssertion(m_manager); + + if (m_conv.is_float_family(f)) + { + switch (f->get_decl_kind()) + { + case OP_FPA_RM_NEAREST_TIES_TO_AWAY: + case OP_FPA_RM_NEAREST_TIES_TO_EVEN: + case OP_FPA_RM_TOWARD_NEGATIVE: + case OP_FPA_RM_TOWARD_POSITIVE: + case OP_FPA_RM_TOWARD_ZERO: m_conv.mk_rounding_mode(f, result); return BR_DONE; + case OP_FPA_NUM: m_conv.mk_numeral(f, num, args, result); return BR_DONE; + case OP_FPA_PLUS_INF: m_conv.mk_pinf(f, result); return BR_DONE; + case OP_FPA_MINUS_INF: m_conv.mk_ninf(f, result); return BR_DONE; + case OP_FPA_PLUS_ZERO: m_conv.mk_pzero(f, result); return BR_DONE; + case OP_FPA_MINUS_ZERO: m_conv.mk_nzero(f, result); return BR_DONE; + case OP_FPA_NAN: m_conv.mk_nan(f, result); return BR_DONE; + case OP_FPA_ADD: + m_conv.mk_add(f,get_precision(f), num, args, result);return BR_DONE; + case OP_FPA_SUB: + m_conv.mk_sub(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_NEG: + m_conv.mk_uminus(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_MUL: + m_conv.mk_mul(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_DIV: + m_conv.mk_div(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_REM: + m_conv.mk_remainder(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_ABS: m_conv.mk_abs(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_MIN: m_conv.mk_min(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_MAX: m_conv.mk_max(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_FMA: + m_conv.mk_fusedma(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_SQRT: + m_conv.mk_sqrt(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_ROUND_TO_INTEGRAL: m_conv.mk_round_to_integral(f, get_precision(f), num, args, result); return BR_DONE; + case OP_FPA_EQ: m_conv.mk_float_eq(f, num, args, result); return BR_DONE; + case OP_FPA_LT: m_conv.mk_float_lt(f, num, args, result); return BR_DONE; + case OP_FPA_GT: m_conv.mk_float_gt(f, num, args, result); return BR_DONE; + case OP_FPA_LE: m_conv.mk_float_le(f, num, args, result); return BR_DONE; + case OP_FPA_GE: m_conv.mk_float_ge(f, num, args, result); return BR_DONE; + case OP_FPA_IS_ZERO: m_conv.mk_is_zero(f, num, args, result); return BR_DONE; + case OP_FPA_IS_NAN: m_conv.mk_is_nan(f, num, args, result); return BR_DONE; + case OP_FPA_IS_INF: m_conv.mk_is_inf(f, num, args, result); return BR_DONE; + case OP_FPA_IS_NORMAL: m_conv.mk_is_normal(f, num, args, result); return BR_DONE; + case OP_FPA_IS_SUBNORMAL: m_conv.mk_is_subnormal(f, num, args, result); return BR_DONE; + case OP_FPA_IS_POSITIVE: m_conv.mk_is_positive(f, num, args, result); return BR_DONE; + case OP_FPA_IS_NEGATIVE: m_conv.mk_is_negative(f, num, args, result); return BR_DONE; + case OP_FPA_TO_FP: m_conv.mk_to_fp(f, num, args, result); return BR_DONE; + case OP_FPA_TO_FP_UNSIGNED: m_conv.mk_to_fp_unsigned(f, num, args, result); return BR_DONE; + case OP_FPA_FP: m_conv.mk_fp(f, num, args, result); return BR_DONE; + case OP_FPA_TO_UBV: m_conv.mk_to_ubv(f, num, args, result); return BR_DONE; + case OP_FPA_TO_SBV: m_conv.mk_to_sbv(f, num, args, result); return BR_DONE; + case OP_FPA_TO_REAL: m_conv.mk_to_real(f, num, args, result); return BR_DONE; + case OP_FPA_TO_IEEE_BV: m_conv.mk_to_ieee_bv(f, num, args, result); return BR_DONE; + case OP_FPA_INTERNAL_BVWRAP: + case OP_FPA_INTERNAL_BVUNWRAP: + case OP_FPA_INTERNAL_TO_REAL_UNSPECIFIED: + case OP_FPA_INTERNAL_TO_UBV_UNSPECIFIED: + case OP_FPA_INTERNAL_TO_SBV_UNSPECIFIED: return BR_FAILED; + default: + TRACE("fpa2bv", tout << "unsupported operator: " << f->get_name() << "\n"; + for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << std::endl;); + NOT_IMPLEMENTED_YET(); + } + } + + if (f->get_family_id() == null_family_id) + { + bool is_float_uf = m_conv.is_float(f->get_range()); + unsigned i = 0; + while (!is_float_uf && i < num) + { + is_float_uf = m_conv.is_float(f->get_domain()[i]); + i++; + } + + if (is_float_uf) + { + m_conv.mk_uninterpreted_function(f, num, args, result); + return BR_DONE; + } + } + + return BR_FAILED; + } + + bool pre_visit(expr * t) + { + TRACE("pre_visit_prec", tout << mk_ismt2_pp(t, m()) << std::endl;); + + if(t->get_kind() == AST_APP && is_app_of(t, to_app(t)->get_family_id(), OP_EQ)) { + //Equation over non-boolean expressions, it should be of form constantI = subexprI + app * a = to_app(t); + + if (a->get_num_args() == 2) { + expr * a0 = a->get_arg(0); + expr * a1 = a->get_arg(1); + func_decl * cnst = 0; + + if (a0->get_kind() == AST_APP && cnst2prec_map->contains(to_app(a0)->get_decl())) + cnst = to_app(a0)->get_decl(); + else if (a1->get_kind() == AST_APP && cnst2prec_map->contains(to_app(a1)->get_decl())) + cnst = to_app(a1)->get_decl(); + + if (cnst == 0) { + // For all equalities that were in the original problem, we don't + // have any precision tracking, so those simply get 100% precision. + set_precision(100); + } + else + set_precision(cnst2prec_map->find(cnst)); + TRACE("pre_visit_prec", tout << "Precision = " << get_precision(NULL) << std::endl;); + } + } + return true; + } + + bool reduce_quantifier(quantifier * old_q, + expr * new_body, + expr * const * new_patterns, + expr * const * new_no_patterns, + expr_ref & result, + proof_ref & result_pr) { + return false; + } + + bool reduce_var(var * t, expr_ref & result, proof_ref & result_pr) { + return false; + } +}; + +template class rewriter_tpl; + +struct fpa2bv_rewriter_prec : public rewriter_tpl { + fpa2bv_rewriter_prec_cfg m_cfg; + fpa2bv_rewriter_prec(ast_manager & m, fpa2bv_converter_prec & c, params_ref const & p): + rewriter_tpl(m, m.proofs_enabled(), m_cfg), + m_cfg(m, c, p) { + } +}; + +#endif diff --git a/src/tactic/fpa/qffp_tactic.cpp b/src/tactic/fpa/qffp_tactic.cpp index 3bee224b307..485e837ee52 100644 --- a/src/tactic/fpa/qffp_tactic.cpp +++ b/src/tactic/fpa/qffp_tactic.cpp @@ -45,7 +45,7 @@ struct has_fp_to_real_predicate { void operator()(app * n) { sort * s = get_sort(n); if (au.is_real(s) && n->get_family_id() == fu.get_family_id() && - is_app(n) && to_app(n)->get_kind() == OP_FPA_TO_REAL) + is_app(n) && to_app(n)->get_decl_kind() == OP_FPA_TO_REAL) throw found(); } }; @@ -53,7 +53,7 @@ struct has_fp_to_real_predicate { class has_fp_to_real_probe : public probe { public: virtual result operator()(goal const & g) { - return !test(g); + return test(g); } virtual ~has_fp_to_real_probe() {} diff --git a/src/tactic/smtlogics/qflia_tactic.cpp b/src/tactic/smtlogics/qflia_tactic.cpp index 6fbf3425529..00f6480d861 100644 --- a/src/tactic/smtlogics/qflia_tactic.cpp +++ b/src/tactic/smtlogics/qflia_tactic.cpp @@ -56,7 +56,7 @@ struct quasi_pb_probe : public probe { } }; -probe * mk_quasi_pb_probe() { +probe * mk_is_quasi_pb_probe() { return mk_and(mk_not(mk_is_unbounded_probe()), alloc(quasi_pb_probe)); } @@ -100,9 +100,11 @@ static tactic * mk_bv2sat_tactic(ast_manager & m) { #define SMALL_SIZE 80000 static tactic * mk_pb_tactic(ast_manager & m) { - params_ref pb2bv_p; - pb2bv_p.set_bool("ite_extra", true); + params_ref pb2bv_p; pb2bv_p.set_uint("pb2bv_all_clauses_limit", 8); + + params_ref bv2sat_p; + bv2sat_p.set_bool("ite_extra", true); return and_then(fail_if_not(mk_is_pb_probe()), fail_if(mk_produce_proofs_probe()), @@ -113,14 +115,16 @@ static tactic * mk_pb_tactic(ast_manager & m) { mk_fail_if_undecided_tactic()), and_then(using_params(mk_pb2bv_tactic(m), pb2bv_p), fail_if_not(mk_is_qfbv_probe()), - mk_bv2sat_tactic(m)))); + using_params(mk_bv2sat_tactic(m), bv2sat_p)))); } static tactic * mk_lia2sat_tactic(ast_manager & m) { params_ref pb2bv_p; - pb2bv_p.set_bool("ite_extra", true); pb2bv_p.set_uint("pb2bv_all_clauses_limit", 8); + + params_ref bv2sat_p; + bv2sat_p.set_bool("ite_extra", true); return and_then(fail_if(mk_is_unbounded_probe()), fail_if(mk_produce_proofs_probe()), @@ -130,7 +134,7 @@ static tactic * mk_lia2sat_tactic(ast_manager & m) { mk_lia2pb_tactic(m), using_params(mk_pb2bv_tactic(m), pb2bv_p), fail_if_not(mk_is_qfbv_probe()), - mk_bv2sat_tactic(m)); + using_params(mk_bv2sat_tactic(m), bv2sat_p)); } // Try to find a model for an unbounded ILP problem. @@ -208,7 +212,7 @@ tactic * mk_qflia_tactic(ast_manager & m, params_ref const & p) { tactic * st = using_params(and_then(preamble_st, or_else(mk_ilp_model_finder_tactic(m), mk_pb_tactic(m), - and_then(fail_if_not(mk_quasi_pb_probe()), + and_then(fail_if_not(mk_is_quasi_pb_probe()), using_params(mk_lia2sat_tactic(m), quasi_pb_p), mk_fail_if_undecided_tactic()), mk_bounded_tactic(m), diff --git a/src/tactic/smtlogics/qflia_tactic.h b/src/tactic/smtlogics/qflia_tactic.h index 9ddaf1f8844..47a2108ae22 100644 --- a/src/tactic/smtlogics/qflia_tactic.h +++ b/src/tactic/smtlogics/qflia_tactic.h @@ -28,4 +28,11 @@ tactic * mk_qflia_tactic(ast_manager & m, params_ref const & p = params_ref()); ADD_TACTIC("qflia", "builtin strategy for solving QF_LIA problems.", "mk_qflia_tactic(m, p)") */ + +probe * mk_is_quasi_pb_probe(); + +/* + ADD_PROBE("is-quasi-pb", "true if the goal is quasi-pb.", "mk_is_quasi_pb_probe()") +*/ + #endif diff --git a/src/test/api.cpp b/src/test/api.cpp index 234d1192cd4..a463bbe47e7 100644 --- a/src/test/api.cpp +++ b/src/test/api.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifdef _WINDOWS #include "z3.h" #include "z3_private.h" diff --git a/src/test/api_bug.cpp b/src/test/api_bug.cpp index 4519b235296..b88840eb607 100644 --- a/src/test/api_bug.cpp +++ b/src/test/api_bug.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include"z3.h" diff --git a/src/test/arith_rewriter.cpp b/src/test/arith_rewriter.cpp index 9eb9e559b26..5ed7c350198 100644 --- a/src/test/arith_rewriter.cpp +++ b/src/test/arith_rewriter.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "arith_rewriter.h" #include "bv_decl_plugin.h" #include "ast_pp.h" diff --git a/src/test/arith_simplifier_plugin.cpp b/src/test/arith_simplifier_plugin.cpp index 59f4996ce4b..8464fd8303b 100644 --- a/src/test/arith_simplifier_plugin.cpp +++ b/src/test/arith_simplifier_plugin.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "arith_eq_solver.h" #include "smt_params.h" diff --git a/src/test/bits.cpp b/src/test/bits.cpp index 7254a177d9b..f32871a5a6b 100644 --- a/src/test/bits.cpp +++ b/src/test/bits.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + // Test some bit hacks #include"util.h" #include"debug.h" diff --git a/src/test/bv_simplifier_plugin.cpp b/src/test/bv_simplifier_plugin.cpp index 77e57f1f5b1..dc930bb82db 100644 --- a/src/test/bv_simplifier_plugin.cpp +++ b/src/test/bv_simplifier_plugin.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "bv_simplifier_plugin.h" #include "arith_decl_plugin.h" #include "ast_pp.h" diff --git a/src/test/check_assumptions.cpp b/src/test/check_assumptions.cpp index 872af714cfa..fa8327cd4af 100644 --- a/src/test/check_assumptions.cpp +++ b/src/test/check_assumptions.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "memory_manager.h" #include "smt_params.h" #include "ast.h" diff --git a/src/test/datalog_parser.cpp b/src/test/datalog_parser.cpp index e23650e3b3e..a927be29a99 100644 --- a/src/test/datalog_parser.cpp +++ b/src/test/datalog_parser.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "datalog_parser.h" #include "ast_pp.h" #include "arith_decl_plugin.h" diff --git a/src/test/ddnf.cpp b/src/test/ddnf.cpp index 024f1bb0fe2..8620bd44150 100644 --- a/src/test/ddnf.cpp +++ b/src/test/ddnf.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "ddnf.h" #include "tbv.h" #include diff --git a/src/test/dl_context.cpp b/src/test/dl_context.cpp index 5c70aa8b55f..deb1300ea9f 100644 --- a/src/test/dl_context.cpp +++ b/src/test/dl_context.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "datalog_parser.h" #include "ast_pp.h" #include "arith_decl_plugin.h" @@ -56,8 +62,9 @@ void dl_context_saturate_file(params_ref & params, const char * f) { ctx.updt_params(params); datalog::parser * parser = datalog::parser::create(ctx, m); - if (!parser->parse_file(f)) { + if (!parser || !parser->parse_file(f)) { warning_msg("ERROR: failed to parse file"); + dealloc(parser); return; } dealloc(parser); diff --git a/src/test/dl_product_relation.cpp b/src/test/dl_product_relation.cpp index 357ccd60414..c375587fb6e 100644 --- a/src/test/dl_product_relation.cpp +++ b/src/test/dl_product_relation.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifdef _WINDOWS #include "dl_context.h" #include "dl_register_engine.h" diff --git a/src/test/dl_query.cpp b/src/test/dl_query.cpp index 39ea0695961..ab5141b1817 100644 --- a/src/test/dl_query.cpp +++ b/src/test/dl_query.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "datalog_parser.h" #include "ast_pp.h" #include "dl_table_relation.h" @@ -58,7 +64,7 @@ void dl_query_test(ast_manager & m, smt_params & fparams, params_ref& params, ctx_q.updt_params(params); { parser* p = parser::create(ctx_q,m); - bool ok = p->parse_file(problem_file); + bool ok = p && p->parse_file(problem_file); dealloc(p); if (!ok) { std::cout << "Could not parse: " << problem_file << "\n"; diff --git a/src/test/dl_relation.cpp b/src/test/dl_relation.cpp index bb1c8614cea..c2ce807a991 100644 --- a/src/test/dl_relation.cpp +++ b/src/test/dl_relation.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifdef _WINDOWS #include "dl_context.h" #include "dl_register_engine.h" diff --git a/src/test/dl_table.cpp b/src/test/dl_table.cpp index d24200f9b95..b14988f1189 100644 --- a/src/test/dl_table.cpp +++ b/src/test/dl_table.cpp @@ -1,4 +1,8 @@ -#ifdef _WINDOWS +/*++ +Copyright (c) 2015 Microsoft Corporation +--*/ +#if defined(_WINDOWS) || defined(_CYGWIN) + #include "dl_context.h" #include "dl_table.h" #include "dl_register_engine.h" @@ -91,9 +95,78 @@ void test_dl_bitvector_table() { test_table(mk_bv_table); } +void test_table_min() { + std::cout << "----- test_table_min -----\n"; + datalog::table_signature sig; + sig.push_back(2); + sig.push_back(4); + sig.push_back(8); + smt_params params; + ast_manager ast_m; + datalog::register_engine re; + datalog::context ctx(ast_m, re, params); + datalog::relation_manager & m = ctx.get_rel_context()->get_rmanager(); + + m.register_plugin(alloc(datalog::bitvector_table_plugin, m)); + + datalog::table_base* tbl = mk_bv_table(m, sig); + datalog::table_base& table = *tbl; + + datalog::table_fact row, row1, row2, row3; + row.push_back(1); + row.push_back(2); + row.push_back(5); + + // Group (1,2,*) + row1 = row; + row[2] = 6; + row2 = row; + row[2] = 5; + row3 = row; + + table.add_fact(row1); + table.add_fact(row2); + table.add_fact(row3); + + // Group (1,3,*) + row[1] = 3; + row1 = row; + row[2] = 7; + row2 = row; + row[2] = 4; + row3 = row; + + table.add_fact(row1); + table.add_fact(row2); + table.add_fact(row3); + + table.display(std::cout); + + unsigned_vector group_by(2); + group_by[0] = 0; + group_by[1] = 1; + + datalog::table_min_fn * min_fn = m.mk_min_fn(table, group_by, 2); + datalog::table_base * min_tbl = (*min_fn)(table); + + min_tbl->display(std::cout); + + row[1] = 2; + row[2] = 5; + SASSERT(min_tbl->contains_fact(row)); + + row[1] = 3; + row[2] = 4; + SASSERT(min_tbl->contains_fact(row)); + + dealloc(min_fn); + min_tbl->deallocate(); + tbl->deallocate(); +} void tst_dl_table() { test_dl_bitvector_table(); + test_table_min(); } #else void tst_dl_table() { diff --git a/src/test/dl_util.cpp b/src/test/dl_util.cpp index 601fd630a41..02e40bbd935 100644 --- a/src/test/dl_util.cpp +++ b/src/test/dl_util.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "dl_util.h" using namespace datalog; diff --git a/src/test/doc.cpp b/src/test/doc.cpp index 593d09cfecd..b2863a629bd 100644 --- a/src/test/doc.cpp +++ b/src/test/doc.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "doc.h" #include "trace.h" #include "vector.h" diff --git a/src/test/expr_rand.cpp b/src/test/expr_rand.cpp index 19a07e98ac0..972c6e242d0 100644 --- a/src/test/expr_rand.cpp +++ b/src/test/expr_rand.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "expr_rand.h" #include "ast_pp.h" #include "bv_decl_plugin.h" diff --git a/src/test/expr_substitution.cpp b/src/test/expr_substitution.cpp index f83bde97d74..8af3f7197d8 100644 --- a/src/test/expr_substitution.cpp +++ b/src/test/expr_substitution.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "expr_substitution.h" #include "smt_params.h" #include "substitution.h" diff --git a/src/test/factor_rewriter.cpp b/src/test/factor_rewriter.cpp index 625710fe1b0..3bcdcd9e99e 100644 --- a/src/test/factor_rewriter.cpp +++ b/src/test/factor_rewriter.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "factor_rewriter.h" #include "bv_decl_plugin.h" #include "ast_pp.h" diff --git a/src/test/fuzzing/expr_delta.cpp b/src/test/fuzzing/expr_delta.cpp index 344e555c9bf..fd5117a744b 100644 --- a/src/test/fuzzing/expr_delta.cpp +++ b/src/test/fuzzing/expr_delta.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "expr_delta.h" #include "ast_pp.h" diff --git a/src/test/fuzzing/expr_rand.cpp b/src/test/fuzzing/expr_rand.cpp index a2aca7e6e35..f56704e45d9 100644 --- a/src/test/fuzzing/expr_rand.cpp +++ b/src/test/fuzzing/expr_rand.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "expr_rand.h" #include "bv_decl_plugin.h" #include "array_decl_plugin.h" diff --git a/src/test/get_implied_equalities.cpp b/src/test/get_implied_equalities.cpp index 2576920cc27..37fbe2004c6 100644 --- a/src/test/get_implied_equalities.cpp +++ b/src/test/get_implied_equalities.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "z3.h" #include "trace.h" #include "debug.h" diff --git a/src/test/heap_trie.cpp b/src/test/heap_trie.cpp index 92ef97f722c..5b0047e82cc 100644 --- a/src/test/heap_trie.cpp +++ b/src/test/heap_trie.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "heap_trie.h" struct unsigned_le { diff --git a/src/test/hilbert_basis.cpp b/src/test/hilbert_basis.cpp index 6fdfb156095..57c8c505078 100644 --- a/src/test/hilbert_basis.cpp +++ b/src/test/hilbert_basis.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "hilbert_basis.h" #include "ast_pp.h" #include "reg_decl_plugins.h" diff --git a/src/test/horn_subsume_model_converter.cpp b/src/test/horn_subsume_model_converter.cpp index 28359b954b2..4b653e3a8d9 100644 --- a/src/test/horn_subsume_model_converter.cpp +++ b/src/test/horn_subsume_model_converter.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include "horn_subsume_model_converter.h" #include "arith_decl_plugin.h" #include "model_smt2_pp.h" diff --git a/src/test/karr.cpp b/src/test/karr.cpp index 87debf66220..4c0737230b5 100644 --- a/src/test/karr.cpp +++ b/src/test/karr.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "hilbert_basis.h" /* diff --git a/src/test/memory.cpp b/src/test/memory.cpp index 0f5a92e2c72..340a1929cae 100644 --- a/src/test/memory.cpp +++ b/src/test/memory.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifdef _WINDOWS #include "z3.h" #include "z3_private.h" diff --git a/src/test/model2expr.cpp b/src/test/model2expr.cpp index abca706c163..f96cee55f8e 100644 --- a/src/test/model2expr.cpp +++ b/src/test/model2expr.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "model2expr.h" #include "ast_pp.h" #include "arith_decl_plugin.h" diff --git a/src/test/model_retrieval.cpp b/src/test/model_retrieval.cpp index f40f89d2201..e42e22539e7 100644 --- a/src/test/model_retrieval.cpp +++ b/src/test/model_retrieval.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include "ast.h" #include "smt_params.h" #include "smt_context.h" diff --git a/src/test/nlarith_util.cpp b/src/test/nlarith_util.cpp index f08fa020e94..2def66b38f3 100644 --- a/src/test/nlarith_util.cpp +++ b/src/test/nlarith_util.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "nlarith_util.h" #include "arith_decl_plugin.h" #include "ast_pp.h" diff --git a/src/test/pdr.cpp b/src/test/pdr.cpp index a9194ec60f6..d95a55a249b 100644 --- a/src/test/pdr.cpp +++ b/src/test/pdr.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "pdr_context.h" #include "reg_decl_plugins.h" @@ -21,7 +27,7 @@ struct test_model_search { }; ast_manager m; - smt_params smt_params; + smt_params m_smt_params; fixedpoint_params fp_params; context ctx; manager pm; @@ -34,8 +40,8 @@ struct test_model_search { test_model_search(): - ctx(smt_params, fp_params, m), - pm(smt_params, 10, m), + ctx(m_smt_params, fp_params, m), + pm(m_smt_params, 10, m), fn(m), initt(fn), pt(ctx, pm, fn), diff --git a/src/test/polynorm.cpp b/src/test/polynorm.cpp index 3593e98ce96..a8f4ab861a9 100644 --- a/src/test/polynorm.cpp +++ b/src/test/polynorm.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "th_rewriter.h" #include "smt2parser.h" #include "arith_decl_plugin.h" diff --git a/src/test/proof_checker.cpp b/src/test/proof_checker.cpp index 12a5245e691..7f9827187bf 100644 --- a/src/test/proof_checker.cpp +++ b/src/test/proof_checker.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "proof_checker.h" #include "ast_ll_pp.h" diff --git a/src/test/qe_arith.cpp b/src/test/qe_arith.cpp index 8b6577b3fcc..bd8266dc299 100644 --- a/src/test/qe_arith.cpp +++ b/src/test/qe_arith.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "qe_arith.h" #include "qe.h" #include "th_rewriter.h" diff --git a/src/test/quant_elim.cpp b/src/test/quant_elim.cpp index 15d23a574c8..0fe7f8eec84 100644 --- a/src/test/quant_elim.cpp +++ b/src/test/quant_elim.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "ast.h" #include "smt_params.h" #include "simplifier.h" diff --git a/src/test/quant_solve.cpp b/src/test/quant_solve.cpp index ae2dadee9e5..aa130612828 100644 --- a/src/test/quant_solve.cpp +++ b/src/test/quant_solve.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "ast.h" #include "smt_params.h" #include "qe.h" diff --git a/src/test/sat_user_scope.cpp b/src/test/sat_user_scope.cpp index e39059563fa..5107361bdba 100644 --- a/src/test/sat_user_scope.cpp +++ b/src/test/sat_user_scope.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "sat_solver.h" #include "util.h" diff --git a/src/test/simplex.cpp b/src/test/simplex.cpp index a70d0d8cf05..61ab7180bd3 100644 --- a/src/test/simplex.cpp +++ b/src/test/simplex.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "sparse_matrix.h" #include "sparse_matrix_def.h" #include "simplex.h" diff --git a/src/test/simplifier.cpp b/src/test/simplifier.cpp index 733c9e23ae6..2e8f434e142 100644 --- a/src/test/simplifier.cpp +++ b/src/test/simplifier.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #ifdef _WINDOWS #include "z3.h" #include "z3_private.h" diff --git a/src/test/small_object_allocator.cpp b/src/test/small_object_allocator.cpp index 1e74a734b46..1ecf865dd28 100644 --- a/src/test/small_object_allocator.cpp +++ b/src/test/small_object_allocator.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include"util.h" #include"trace.h" diff --git a/src/test/smt2print_parse.cpp b/src/test/smt2print_parse.cpp index 39543d1419c..982e2e3f54c 100644 --- a/src/test/smt2print_parse.cpp +++ b/src/test/smt2print_parse.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + // This is to test the print-parse facilities over the API // for SMT-LIB2. diff --git a/src/test/smt_context.cpp b/src/test/smt_context.cpp index 49ada8ebda1..6c44b8b1dfa 100644 --- a/src/test/smt_context.cpp +++ b/src/test/smt_context.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "smt_context.h" #include "reg_decl_plugins.h" diff --git a/src/test/sorting_network.cpp b/src/test/sorting_network.cpp index dd46b61df02..4802e2bec45 100644 --- a/src/test/sorting_network.cpp +++ b/src/test/sorting_network.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "trace.h" #include "vector.h" #include "ast.h" diff --git a/src/test/substitution.cpp b/src/test/substitution.cpp index 0d7fb58564c..cdc7f20803c 100644 --- a/src/test/substitution.cpp +++ b/src/test/substitution.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "expr_substitution.h" #include "smt_params.h" #include "substitution.h" diff --git a/src/test/tbv.cpp b/src/test/tbv.cpp index c53eb36711b..7637c7e83ca 100644 --- a/src/test/tbv.cpp +++ b/src/test/tbv.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "tbv.h" static void tst1(unsigned num_bits) { diff --git a/src/test/test_util.h b/src/test/test_util.h index c83a94dbf80..c81524b0e72 100644 --- a/src/test/test_util.h +++ b/src/test/test_util.h @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #pragma once #include "stopwatch.h" diff --git a/src/test/theory_dl.cpp b/src/test/theory_dl.cpp index 9521a8932f8..463625c88e3 100644 --- a/src/test/theory_dl.cpp +++ b/src/test/theory_dl.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "smt_context.h" #include "dl_decl_plugin.h" #include "ast_pp.h" diff --git a/src/test/theory_pb.cpp b/src/test/theory_pb.cpp index ee1ec126af3..3a229d951cb 100644 --- a/src/test/theory_pb.cpp +++ b/src/test/theory_pb.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "smt_context.h" #include "ast_pp.h" #include "model_v2_pp.h" diff --git a/src/test/timeout.cpp b/src/test/timeout.cpp index 19daebb129a..3200069288e 100644 --- a/src/test/timeout.cpp +++ b/src/test/timeout.cpp @@ -1,4 +1,10 @@ +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + + #include "timeout.h" #include "trace.h" diff --git a/src/test/udoc_relation.cpp b/src/test/udoc_relation.cpp index 7be048c731d..dc88e20af97 100644 --- a/src/test/udoc_relation.cpp +++ b/src/test/udoc_relation.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include "udoc_relation.h" #include "trace.h" #include "vector.h" @@ -160,6 +166,7 @@ class udoc_tester { test_join_project(); test_join_project2(); + test_join_project3(); test_filter_neg4(false); test_filter_neg4(true); @@ -519,6 +526,55 @@ class udoc_tester { t2->deallocate(); } + void test_join_project3() + { + datalog::relation_signature sig; + sig.push_back(bv.mk_sort(2)); + sig.push_back(bv.mk_sort(2)); + + unsigned_vector jc1, jc2, pc; + jc1.push_back(0); + jc1.push_back(1); + jc2.push_back(1); + jc2.push_back(0); + pc.push_back(0); + pc.push_back(1); + + scoped_ptr join_project_fn; + + udoc_relation* t1 = mk_empty(sig); + { + datalog::relation_fact fact1(m); + fact1.push_back(bv.mk_numeral(rational(3), 2)); + fact1.push_back(bv.mk_numeral(rational(1), 2)); + t1->add_fact(fact1); + } + + udoc_relation *t2 = mk_empty(sig); + { + datalog::relation_fact fact1(m); + fact1.push_back(bv.mk_numeral(rational(0), 2)); + fact1.push_back(bv.mk_numeral(rational(3), 2)); + t2->add_fact(fact1); + fact1.reset(); + fact1.push_back(bv.mk_numeral(rational(1), 2)); + fact1.push_back(bv.mk_numeral(rational(3), 2)); + t2->add_fact(fact1); + } + + t1->display(std::cout << "t1:"); + t2->display(std::cout << "t2:"); + join_project_fn = p.mk_join_project_fn(*t1, *t2, jc1.size(), jc1.c_ptr(), jc2.c_ptr(), pc.size(), pc.c_ptr()); + + relation_base* t; + t = (*join_project_fn)(*t1, *t2); + t->display(std::cout << "t:"); + cr.verify_join_project(*t1, *t2, *t, jc1, jc2, pc); + t->deallocate(); + t1->deallocate(); + t2->deallocate(); + } + void test_rename() { udoc_relation* t1; // rename diff --git a/src/util/bit_vector.h b/src/util/bit_vector.h index e874d8a3dfd..f3fd7c27b9f 100644 --- a/src/util/bit_vector.h +++ b/src/util/bit_vector.h @@ -94,7 +94,8 @@ class bit_vector { } void reset() { - memset(m_data, 0, m_capacity * sizeof(unsigned)); + if (m_data) + memset(m_data, 0, m_capacity * sizeof(unsigned)); m_num_bits = 0; } diff --git a/src/util/memory_manager.cpp b/src/util/memory_manager.cpp index e911ff505a8..7539e7ba30a 100644 --- a/src/util/memory_manager.cpp +++ b/src/util/memory_manager.cpp @@ -1,3 +1,9 @@ + +/*++ +Copyright (c) 2015 Microsoft Corporation + +--*/ + #include #include #include diff --git a/src/util/mpf.h b/src/util/mpf.h index 63e0ed000a7..28329810e0d 100644 --- a/src/util/mpf.h +++ b/src/util/mpf.h @@ -169,7 +169,7 @@ class mpf_manager { bool is_ninf(mpf const & x); bool is_normal(mpf const & x); bool is_denormal(mpf const & x); - bool is_regular(mpf const & x) { return x.sbits == 0 || is_normal(x) || is_denormal(x); } + bool is_regular(mpf const & x) { return x.sbits == 0 || is_zero(x) || is_normal(x) || is_denormal(x); } bool is_int(mpf const & x); diff --git a/tests/chat1.smt2 b/tests/chat1.smt2 deleted file mode 100644 index e6e11076bd2..00000000000 --- a/tests/chat1.smt2 +++ /dev/null @@ -1,3380 +0,0 @@ -(declare-const |dn([7,Main.main],41)| Bool) -(declare-const |dn([3,7],24)| Bool) -(declare-const |dn([7,Main.main],47)| Bool) -(declare-const |dn([9,Main.main],86)| Bool) -(declare-const |dn([7,Main.main],51)| Bool) -(declare-const |dn([3,7],20)| Bool) -(declare-const |dn([6,9],91)| Bool) -(declare-const |scc(3)| Bool) -(declare-const |dn([6,9],92)| Bool) -(declare-const |scc(4)| Bool) -(declare-const |dn([7,Main.main],54)| Bool) -(declare-const |scc(0)| Bool) -(declare-const |dn([Main.main],109)| Bool) -(declare-const |dn([7,Main.main],58)| Bool) -(declare-const |dn([Main.main],104)| Bool) -(declare-const |dn([Main.main],102)| Bool) -(declare-const |dn([8,Main.main],101)| Bool) -(declare-const |dn([6,9],95)| Bool) -(declare-const |dn([8,Main.main],96)| Bool) -(declare-const |dn([3,7],28)| Bool) -(declare-const |dn([Main.main],106)| Bool) -(declare-const |dn([2,3],36)| Bool) -(declare-const |dn([4,1],78)| Bool) -(declare-const |dn([Main.main],114)| Bool) -(declare-const |dn([2,3],35)| Bool) -(declare-const |dn([2,3],38)| Bool) -(declare-const |dn([5,1],63)| Bool) -(declare-const |dn([7,Main.main],39)| Bool) -(declare-const |dn([3,7],33)| Bool) -(declare-const |dn([9,Main.main],88)| Bool) -(declare-const |dn([4,1],80)| Bool) -(declare-const |dn([Main.main],116)| Bool) -(declare-const |dn([Main.main],111)| Bool) -(declare-const |dn([7,Main.main],42)| Bool) -(declare-const |dn([9,Main.main],85)| Bool) -(declare-const |dn([3,7],27)| Bool) -(declare-const |dn([1,3],64)| Bool) -(declare-const |dn([9,Main.main],83)| Bool) -(declare-const |dn([1,3],67)| Bool) -(declare-const |dn([7,Main.main],40)| Bool) -(declare-const |dn([3,7],25)| Bool) -(declare-const |dn([6,9],90)| Bool) -(declare-const |dn([7,Main.main],60)| Bool) -(declare-const |dn([7,Main.main],50)| Bool) -(declare-const |dn([5,1],62)| Bool) -(declare-const |dn([3,7],22)| Bool) -(declare-const |dn([7,Main.main],53)| Bool) -(declare-const |dn([6,9],93)| Bool) -(declare-const |dn([7,Main.main],57)| Bool) -(declare-const |dn([Main.main],108)| Bool) -(declare-const |dn([7,Main.main],55)| Bool) -(declare-const |scc(1)| Bool) -(declare-const |dn([Main.main],105)| Bool) -(declare-const |scc(2)| Bool) -(declare-const |dn([8,Main.main],97)| Bool) -(declare-const |dn([Main.main],103)| Bool) -(declare-const |scc(5)| Bool) -(declare-const |dn([4,1],70)| Bool) -(declare-const |dn([6,9],94)| Bool) -(declare-const |dn([8,Main.main],100)| Bool) -(declare-const |dn([7,Main.main],59)| Bool) -(declare-const |dn([5,1],61)| Bool) -(declare-const |dn([4,1],69)| Bool) -(declare-const |dn([3,7],29)| Bool) -(declare-const |dn([3,7],31)| Bool) -(declare-const |dn([Main.main],113)| Bool) -(declare-const |dn([4,1],79)| Bool) -(declare-const |dn([2,3],34)| Bool) -(declare-const |dn([Main.main],115)| Bool) -(declare-const |dn([2,3],37)| Bool) -(declare-const |dn([1,3],68)| Bool) -(declare-const |dn([4,1],81)| Bool) -(declare-const |scc(7)| Bool) -(declare-const |dn([9,Main.main],89)| Bool) -(declare-const |dn([1,3],66)| Bool) -(declare-const |dn([9,Main.main],84)| Bool) -(declare-const |dn([1,3],65)| Bool) -(declare-const |dn([7,Main.main],43)| Bool) -(declare-const |dn([9,Main.main],82)| Bool) -(declare-const |dn([7,Main.main],45)| Bool) -(declare-const |dn([3,7],30)| Bool) -(declare-const |scc(8)| Bool) -(declare-const |dn([9,Main.main],87)| Bool) -(declare-const |dn([3,7],21)| Bool) -(declare-const |dn([7,Main.main],49)| Bool) -(declare-const |scc(6)| Bool) -(declare-const |dn([7,Main.main],41)_dn([3,7],20)| Bool) -(declare-const |dn([7,Main.main],41)_dn([7,Main.main],42)| Bool) -(declare-const |dn([3,7],24)_dn([3,7],25)| Bool) -(declare-const |dn([3,7],24)_dn([4,1],80)| Bool) -(declare-const |dn([7,Main.main],47)_dn([7,Main.main],41)| Bool) -(declare-const |dn([7,Main.main],47)_dn([7,Main.main],45)| Bool) -(declare-const |dn([9,Main.main],86)_dn([9,Main.main],87)| Bool) -(declare-const |dn([9,Main.main],86)_dn([6,9],91)| Bool) -(declare-const |dn([7,Main.main],51)_dn([9,Main.main],84)| Bool) -(declare-const |dn([3,7],20)_dn([3,7],21)| Bool) -(declare-const |dn([3,7],20)_dn([1,3],64)| Bool) -(declare-const |dn([6,9],91)_dn([7,Main.main],54)| Bool) -(declare-const |dn([6,9],91)_dn([6,9],92)| Bool) -(declare-const |scc(3)_dn([3,7],20)| Bool) -(declare-const |scc(3)_dn([3,7],22)| Bool) -(declare-const |scc(3)_dn([3,7],27)| Bool) -(declare-const |scc(3)_dn([3,7],29)| Bool) -(declare-const |scc(3)_dn([3,7],31)| Bool) -(declare-const |scc(3)_dn([3,7],33)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],95)| Bool) -(declare-const |scc(4)_dn([2,3],35)| Bool) -(declare-const |scc(4)_dn([4,1],70)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],54)_scc(1)| Bool) -(declare-const |dn([7,Main.main],54)_scc(7)| Bool) -(declare-const |scc(0)_dn([3,7],24)| Bool) -(declare-const |scc(0)_dn([2,3],34)| Bool) -(declare-const |dn([Main.main],109)_dn([Main.main],111)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],58)_scc(1)| Bool) -(declare-const |dn([7,Main.main],58)_scc(7)| Bool) -(declare-const |dn([Main.main],104)_dn([7,Main.main],49)| Bool) -(declare-const |dn([Main.main],104)_dn([Main.main],105)| Bool) -(declare-const |dn([8,Main.main],101)_dn([8,Main.main],96)| Bool) -(declare-const |dn([8,Main.main],101)_dn([8,Main.main],97)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],95)_scc(1)| Bool) -(declare-const |dn([8,Main.main],96)_dn([8,Main.main],97)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],28)_scc(6)| Bool) -(declare-const |dn([Main.main],106)_dn([7,Main.main],47)| Bool) -(declare-const |dn([2,3],36)_dn([3,7],31)| Bool) -(declare-const |dn([2,3],36)_dn([2,3],37)| Bool) -(declare-const |dn([4,1],78)_dn([4,1],79)| Bool) -(declare-const |dn([4,1],78)_scc(4)| Bool) -(declare-const |dn([Main.main],114)_dn([9,Main.main],83)| Bool) -(declare-const |dn([Main.main],114)_dn([Main.main],115)| Bool) -(declare-const |dn([2,3],35)_dn([3,7],33)| Bool) -(declare-const |dn([2,3],35)_dn([2,3],36)| Bool) -(declare-const |dn([2,3],38)_dn([2,3],34)| Bool) -(declare-const |dn([2,3],38)_dn([2,3],35)| Bool) -(declare-const |dn([5,1],63)_dn([5,1],61)| Bool) -(declare-const |dn([5,1],63)_dn([5,1],62)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],58)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],31)| Bool) -(declare-const |dn([9,Main.main],88)_dn([9,Main.main],89)| Bool) -(declare-const |dn([4,1],80)_dn([4,1],81)| Bool) -(declare-const |dn([Main.main],116)_dn([Main.main],113)| Bool) -(declare-const |dn([Main.main],111)_dn([Main.main],102)| Bool) -(declare-const |dn([Main.main],111)_dn([Main.main],103)| Bool) -(declare-const |dn([7,Main.main],42)_dn([3,7],22)| Bool) -(declare-const |dn([7,Main.main],42)_dn([7,Main.main],43)| Bool) -(declare-const |dn([9,Main.main],85)_dn([9,Main.main],86)| Bool) -(declare-const |dn([9,Main.main],85)_dn([6,9],90)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],28)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],30)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],33)| Bool) -(declare-const |dn([1,3],64)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],64)_dn([1,3],67)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],67)_dn([5,1],61)| Bool) -(declare-const |dn([1,3],67)_dn([1,3],68)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],58)| Bool) -(declare-const |dn([3,7],25)_dn([1,3],67)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],95)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],50)_scc(1)| Bool) -(declare-const |dn([7,Main.main],50)_scc(7)| Bool) -(declare-const |dn([5,1],62)_dn([5,1],61)| Bool) -(declare-const |dn([5,1],62)_dn([5,1],63)| Bool) -(declare-const |dn([5,1],62)_scc(2)| Bool) -(declare-const |dn([3,7],22)_dn([1,3],65)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],58)| Bool) -(declare-const |dn([6,9],93)_dn([9,Main.main],88)| Bool) -(declare-const |dn([6,9],93)_dn([6,9],94)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],58)| Bool) -(declare-const |dn([Main.main],108)_dn([8,Main.main],97)| Bool) -(declare-const |dn([Main.main],108)_dn([Main.main],109)| Bool) -(declare-const |dn([7,Main.main],55)_dn([6,9],95)| Bool) -(declare-const |scc(1)_dn([7,Main.main],39)| Bool) -(declare-const |scc(1)_dn([7,Main.main],47)| Bool) -(declare-const |scc(1)_dn([7,Main.main],49)| Bool) -(declare-const |scc(1)_dn([7,Main.main],50)| Bool) -(declare-const |scc(1)_dn([7,Main.main],51)| Bool) -(declare-const |scc(1)_dn([7,Main.main],54)| Bool) -(declare-const |scc(1)_dn([7,Main.main],55)| Bool) -(declare-const |scc(1)_dn([7,Main.main],57)| Bool) -(declare-const |scc(1)_dn([7,Main.main],58)| Bool) -(declare-const |scc(1)_dn([7,Main.main],59)| Bool) -(declare-const |scc(1)_dn([6,9],93)| Bool) -(declare-const |scc(1)_scc(7)| Bool) -(declare-const |dn([Main.main],105)_dn([7,Main.main],50)| Bool) -(declare-const |dn([Main.main],105)_dn([Main.main],106)| Bool) -(declare-const |scc(2)_dn([3,7],20)| Bool) -(declare-const |scc(2)_dn([3,7],22)| Bool) -(declare-const |scc(2)_dn([3,7],27)| Bool) -(declare-const |scc(2)_dn([3,7],29)| Bool) -(declare-const |scc(2)_dn([3,7],31)| Bool) -(declare-const |scc(2)_dn([3,7],33)| Bool) -(declare-const |dn([8,Main.main],97)_dn([3,7],27)| Bool) -(declare-const |dn([Main.main],103)_dn([7,Main.main],39)| Bool) -(declare-const |dn([Main.main],103)_dn([Main.main],104)| Bool) -(declare-const |scc(5)_dn([5,1],63)| Bool) -(declare-const |scc(5)_dn([8,Main.main],100)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],95)| Bool) -(declare-const |dn([8,Main.main],100)_dn([4,1],78)| Bool) -(declare-const |dn([8,Main.main],100)_dn([8,Main.main],101)| Bool) -(declare-const |dn([7,Main.main],59)_dn([7,Main.main],60)| Bool) -(declare-const |dn([7,Main.main],59)_dn([6,9],95)| Bool) -(declare-const |dn([5,1],61)_dn([5,1],62)| Bool) -(declare-const |dn([5,1],61)_dn([5,1],63)| Bool) -(declare-const |dn([4,1],69)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],69)_dn([4,1],80)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],28)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],30)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],31)_dn([5,1],62)| Bool) -(declare-const |dn([Main.main],113)_dn([9,Main.main],82)| Bool) -(declare-const |dn([Main.main],113)_dn([Main.main],114)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],69)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],80)| Bool) -(declare-const |dn([2,3],34)_dn([2,3],35)| Bool) -(declare-const |dn([Main.main],115)_dn([Main.main],111)| Bool) -(declare-const |dn([Main.main],115)_dn([Main.main],116)| Bool) -(declare-const |dn([2,3],37)_dn([2,3],38)| Bool) -(declare-const |dn([2,3],37)_dn([7,Main.main],58)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],64)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],67)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],69)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],80)| Bool) -(declare-const |scc(7)_dn([7,Main.main],39)| Bool) -(declare-const |scc(7)_dn([7,Main.main],47)| Bool) -(declare-const |scc(7)_dn([7,Main.main],49)| Bool) -(declare-const |scc(7)_dn([7,Main.main],50)| Bool) -(declare-const |scc(7)_dn([7,Main.main],51)| Bool) -(declare-const |scc(7)_dn([7,Main.main],53)| Bool) -(declare-const |scc(7)_dn([7,Main.main],54)| Bool) -(declare-const |scc(7)_dn([7,Main.main],55)| Bool) -(declare-const |scc(7)_dn([7,Main.main],58)| Bool) -(declare-const |scc(7)_dn([7,Main.main],59)| Bool) -(declare-const |scc(7)_scc(1)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],64)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],67)| Bool) -(declare-const |dn([1,3],66)_scc(0)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],85)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],65)_dn([1,3],66)| Bool) -(declare-const |dn([1,3],65)_dn([4,1],69)| Bool) -(declare-const |dn([7,Main.main],43)_dn([7,Main.main],40)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],88)| Bool) -(declare-const |dn([7,Main.main],45)_dn([7,Main.main],40)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],30)_scc(5)| Bool) -(declare-const |scc(8)_dn([8,Main.main],96)| Bool) -(declare-const |scc(8)_dn([Main.main],108)| Bool) -(declare-const |dn([9,Main.main],87)_dn([7,Main.main],53)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],88)| Bool) -(declare-const |dn([9,Main.main],87)_scc(7)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],33)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],58)| Bool) -(declare-const |scc(6)_dn([3,7],29)| Bool) -(assert |dn([Main.main],113)|) -(assert (= |dn([7,Main.main],41)| (or |dn([7,Main.main],41)_dn([3,7],20)| |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (not (and |dn([7,Main.main],41)_dn([7,Main.main],42)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (= |dn([3,7],24)| (or |dn([3,7],24)_dn([3,7],25)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([3,7],25)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([3,7],24)_dn([3,7],25)|))) -(assert (= |dn([7,Main.main],47)| (or |dn([7,Main.main],47)_dn([7,Main.main],41)| |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (not (and |dn([7,Main.main],47)_dn([7,Main.main],41)| |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (not (and |dn([7,Main.main],47)_dn([7,Main.main],45)| |dn([7,Main.main],47)_dn([7,Main.main],41)|))) -(assert (= |dn([9,Main.main],86)| (or |dn([9,Main.main],86)_dn([9,Main.main],87)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([9,Main.main],87)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([9,Main.main],86)_dn([9,Main.main],87)|))) -(assert (= |dn([7,Main.main],51)| (or |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (= |dn([3,7],20)| (or |dn([3,7],20)_dn([3,7],21)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([3,7],21)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([3,7],20)_dn([3,7],21)|))) -(assert (= |dn([6,9],91)| (or |dn([6,9],91)_dn([7,Main.main],54)| |dn([6,9],91)_dn([6,9],92)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([6,9],91)_dn([6,9],92)|))) -(assert (not (and |dn([6,9],91)_dn([6,9],92)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (= |scc(3)| (or |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],31)|))) -(assert (= |dn([6,9],92)| (or |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (= |scc(4)| (or |scc(4)_dn([2,3],35)| |scc(4)_dn([4,1],70)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |scc(4)_dn([4,1],70)|))) -(assert (not (and |scc(4)_dn([4,1],70)| |scc(4)_dn([2,3],35)|))) -(assert (= |dn([7,Main.main],54)| (or |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_scc(1)|))) -(assert (= |scc(0)| (or |scc(0)_dn([3,7],24)| |scc(0)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([3,7],24)| |scc(0)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([2,3],34)| |scc(0)_dn([3,7],24)|))) -(assert (= |dn([Main.main],109)| (or |dn([Main.main],109)_dn([Main.main],111)|))) -(assert (= |dn([7,Main.main],58)| (or |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_scc(1)|))) -(assert (= |dn([Main.main],104)| (or |dn([Main.main],104)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (not (and |dn([Main.main],104)_dn([Main.main],105)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not |dn([Main.main],102)|)) -(assert (= |dn([8,Main.main],101)| (or |dn([8,Main.main],101)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (= |dn([6,9],95)| (or |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (= |dn([8,Main.main],96)| (or |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (= |dn([3,7],28)| (or |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (= |dn([Main.main],106)| (or |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (= |dn([2,3],36)| (or |dn([2,3],36)_dn([3,7],31)| |dn([2,3],36)_dn([2,3],37)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([2,3],36)_dn([2,3],37)|))) -(assert (not (and |dn([2,3],36)_dn([2,3],37)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (= |dn([4,1],78)| (or |dn([4,1],78)_dn([4,1],79)| |dn([4,1],78)_scc(4)|))) -(assert (not (and |dn([4,1],78)_dn([4,1],79)| |dn([4,1],78)_scc(4)|))) -(assert (not (and |dn([4,1],78)_scc(4)| |dn([4,1],78)_dn([4,1],79)|))) -(assert (= |dn([Main.main],114)| (or |dn([Main.main],114)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (not (and |dn([Main.main],114)_dn([Main.main],115)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (= |dn([2,3],35)| (or |dn([2,3],35)_dn([3,7],33)| |dn([2,3],35)_dn([2,3],36)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([2,3],35)_dn([2,3],36)|))) -(assert (not (and |dn([2,3],35)_dn([2,3],36)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (= |dn([2,3],38)| (or |dn([2,3],38)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (= |dn([5,1],63)| (or |dn([5,1],63)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (= |dn([7,Main.main],39)| (or |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (= |dn([3,7],33)| (or |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (= |dn([9,Main.main],88)| (or |dn([9,Main.main],88)_dn([9,Main.main],89)|))) -(assert (= |dn([4,1],80)| (or |dn([4,1],80)_dn([4,1],81)|))) -(assert (= |dn([Main.main],116)| (or |dn([Main.main],116)_dn([Main.main],113)|))) -(assert (= |dn([Main.main],111)| (or |dn([Main.main],111)_dn([Main.main],102)| |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (not (and |dn([Main.main],111)_dn([Main.main],102)| |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (not (and |dn([Main.main],111)_dn([Main.main],103)| |dn([Main.main],111)_dn([Main.main],102)|))) -(assert (= |dn([7,Main.main],42)| (or |dn([7,Main.main],42)_dn([3,7],22)| |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (not (and |dn([7,Main.main],42)_dn([7,Main.main],43)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (= |dn([9,Main.main],85)| (or |dn([9,Main.main],85)_dn([9,Main.main],86)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([9,Main.main],86)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([9,Main.main],85)_dn([9,Main.main],86)|))) -(assert (= |dn([3,7],27)| (or |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (= |dn([1,3],64)| (or |dn([1,3],64)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (= |dn([9,Main.main],83)| (or |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],67)| (or |dn([1,3],67)_dn([5,1],61)| |dn([1,3],67)_dn([1,3],68)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([1,3],67)_dn([1,3],68)|))) -(assert (not (and |dn([1,3],67)_dn([1,3],68)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (= |dn([7,Main.main],40)| (or |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (= |dn([3,7],25)| (or |dn([3,7],25)_dn([1,3],67)|))) -(assert (= |dn([6,9],90)| (or |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (= |dn([7,Main.main],60)| (or |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (= |dn([7,Main.main],50)| (or |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_scc(1)|))) -(assert (= |dn([5,1],62)| (or |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_scc(2)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_scc(2)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (= |dn([3,7],22)| (or |dn([3,7],22)_dn([1,3],65)|))) -(assert (= |dn([7,Main.main],53)| (or |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (= |dn([6,9],93)| (or |dn([6,9],93)_dn([9,Main.main],88)| |dn([6,9],93)_dn([6,9],94)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([6,9],93)_dn([6,9],94)|))) -(assert (not (and |dn([6,9],93)_dn([6,9],94)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (= |dn([7,Main.main],57)| (or |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (= |dn([Main.main],108)| (or |dn([Main.main],108)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (not (and |dn([Main.main],108)_dn([Main.main],109)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (= |dn([7,Main.main],55)| (or |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (= |scc(1)| (or |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([6,9],93)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([6,9],93)|))) -(assert (= |dn([Main.main],105)| (or |dn([Main.main],105)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (not (and |dn([Main.main],105)_dn([Main.main],106)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (= |scc(2)| (or |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],31)|))) -(assert (= |dn([8,Main.main],97)| (or |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (= |dn([Main.main],103)| (or |dn([Main.main],103)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (not (and |dn([Main.main],103)_dn([Main.main],104)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (= |scc(5)| (or |scc(5)_dn([5,1],63)| |scc(5)_dn([8,Main.main],100)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |scc(5)_dn([8,Main.main],100)|))) -(assert (not (and |scc(5)_dn([8,Main.main],100)| |scc(5)_dn([5,1],63)|))) -(assert (not |dn([4,1],70)|)) -(assert (= |dn([6,9],94)| (or |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (= |dn([8,Main.main],100)| (or |dn([8,Main.main],100)_dn([4,1],78)| |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (not (and |dn([8,Main.main],100)_dn([8,Main.main],101)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (= |dn([7,Main.main],59)| (or |dn([7,Main.main],59)_dn([7,Main.main],60)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([7,Main.main],60)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([7,Main.main],59)_dn([7,Main.main],60)|))) -(assert (= |dn([5,1],61)| (or |dn([5,1],61)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (= |dn([4,1],69)| (or |dn([4,1],69)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (= |dn([3,7],29)| (or |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (= |dn([3,7],31)| (or |dn([3,7],31)_dn([5,1],62)|))) -(assert (= |dn([Main.main],113)| (or |dn([Main.main],113)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (not (and |dn([Main.main],113)_dn([Main.main],114)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (= |dn([4,1],79)| (or |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (= |dn([2,3],34)| (or |dn([2,3],34)_dn([2,3],35)|))) -(assert (= |dn([Main.main],115)| (or |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],116)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (= |dn([2,3],37)| (or |dn([2,3],37)_dn([2,3],38)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([2,3],38)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([2,3],37)_dn([2,3],38)|))) -(assert (= |dn([1,3],68)| (or |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (= |dn([4,1],81)| (or |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (= |scc(7)| (or |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],59)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],59)|))) -(assert (= |dn([9,Main.main],89)| (or |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],66)| (or |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (= |dn([9,Main.main],84)| (or |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (= |dn([1,3],65)| (or |dn([1,3],65)_dn([1,3],66)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([1,3],66)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([1,3],65)_dn([1,3],66)|))) -(assert (= |dn([7,Main.main],43)| (or |dn([7,Main.main],43)_dn([7,Main.main],40)|))) -(assert (= |dn([9,Main.main],82)| (or |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (= |dn([7,Main.main],45)| (or |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (= |dn([3,7],30)| (or |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (= |scc(8)| (or |scc(8)_dn([8,Main.main],96)| |scc(8)_dn([Main.main],108)|))) -(assert (not (and |scc(8)_dn([8,Main.main],96)| |scc(8)_dn([Main.main],108)|))) -(assert (not (and |scc(8)_dn([Main.main],108)| |scc(8)_dn([8,Main.main],96)|))) -(assert (= |dn([9,Main.main],87)| (or |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (= |dn([7,Main.main],49)| (or |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (= |scc(6)| (or |scc(6)_dn([3,7],29)|))) -(assert (= |dn([7,Main.main],41)| (or |dn([7,Main.main],47)_dn([7,Main.main],41)|))) -(assert (= |dn([3,7],24)| (or |scc(0)_dn([3,7],24)|))) -(assert (= |dn([7,Main.main],47)| (or |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (= |dn([9,Main.main],86)| (or |dn([9,Main.main],85)_dn([9,Main.main],86)|))) -(assert (= |dn([7,Main.main],51)| (or |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (= |dn([3,7],20)| (or |dn([7,Main.main],41)_dn([3,7],20)| |scc(2)_dn([3,7],20)| |scc(3)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (= |dn([6,9],91)| (or |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not |scc(3)|)) -(assert (= |dn([6,9],92)| (or |dn([6,9],91)_dn([6,9],92)|))) -(assert (= |scc(4)| (or |dn([4,1],78)_scc(4)|))) -(assert (= |dn([7,Main.main],54)| (or |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (= |scc(0)| (or |dn([1,3],66)_scc(0)|))) -(assert (= |dn([Main.main],109)| (or |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (= |dn([7,Main.main],58)| (or |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (= |dn([Main.main],104)| (or |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (= |dn([Main.main],102)| (or |dn([Main.main],111)_dn([Main.main],102)|))) -(assert (= |dn([8,Main.main],101)| (or |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (= |dn([6,9],95)| (or |dn([7,Main.main],55)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (= |dn([8,Main.main],96)| (or |scc(8)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (not (and |scc(8)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],96)| |scc(8)_dn([8,Main.main],96)|))) -(assert (= |dn([3,7],28)| (or |dn([3,7],27)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (= |dn([Main.main],106)| (or |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (= |dn([2,3],36)| (or |dn([2,3],35)_dn([2,3],36)|))) -(assert (= |dn([4,1],78)| (or |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (= |dn([Main.main],114)| (or |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (= |dn([2,3],35)| (or |scc(4)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],34)_dn([2,3],35)| |scc(4)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],34)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |scc(4)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)|))) -(assert (= |dn([2,3],38)| (or |dn([2,3],37)_dn([2,3],38)|))) -(assert (= |dn([5,1],63)| (or |scc(5)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |scc(5)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |scc(5)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (= |dn([7,Main.main],39)| (or |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (= |dn([3,7],33)| (or |dn([2,3],35)_dn([3,7],33)| |scc(2)_dn([3,7],33)| |scc(3)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (= |dn([9,Main.main],88)| (or |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (= |dn([4,1],80)| (or |dn([3,7],24)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (= |dn([Main.main],116)| (or |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (= |dn([Main.main],111)| (or |dn([Main.main],109)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (not (and |dn([Main.main],109)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],109)_dn([Main.main],111)|))) -(assert (= |dn([7,Main.main],42)| (or |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (= |dn([9,Main.main],85)| (or |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (= |dn([3,7],27)| (or |dn([8,Main.main],97)_dn([3,7],27)| |scc(2)_dn([3,7],27)| |scc(3)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (= |dn([1,3],64)| (or |dn([3,7],20)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (= |dn([9,Main.main],83)| (or |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (= |dn([1,3],67)| (or |dn([3,7],25)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (= |dn([7,Main.main],40)| (or |dn([7,Main.main],43)_dn([7,Main.main],40)| |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (not (and |dn([7,Main.main],43)_dn([7,Main.main],40)| |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (not (and |dn([7,Main.main],45)_dn([7,Main.main],40)| |dn([7,Main.main],43)_dn([7,Main.main],40)|))) -(assert (= |dn([3,7],25)| (or |dn([3,7],24)_dn([3,7],25)|))) -(assert (= |dn([6,9],90)| (or |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (= |dn([7,Main.main],60)| (or |dn([7,Main.main],59)_dn([7,Main.main],60)|))) -(assert (= |dn([7,Main.main],50)| (or |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (= |dn([5,1],62)| (or |dn([3,7],31)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([3,7],31)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (not (and |dn([3,7],31)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([3,7],31)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([3,7],31)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (= |dn([3,7],22)| (or |dn([7,Main.main],42)_dn([3,7],22)| |scc(2)_dn([3,7],22)| |scc(3)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (= |dn([7,Main.main],53)| (or |dn([9,Main.main],87)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (= |dn([6,9],93)| (or |scc(1)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (= |dn([7,Main.main],57)| (or |scc(1)_dn([7,Main.main],57)|))) -(assert (= |dn([Main.main],108)| (or |scc(8)_dn([Main.main],108)|))) -(assert (= |dn([7,Main.main],55)| (or |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (= |scc(1)| (or |dn([6,9],95)_scc(1)| |scc(7)_scc(1)| |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (= |dn([Main.main],105)| (or |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (= |scc(2)| (or |dn([5,1],62)_scc(2)|))) -(assert (= |dn([8,Main.main],97)| (or |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (= |dn([Main.main],103)| (or |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (= |scc(5)| (or |dn([3,7],30)_scc(5)|))) -(assert (= |dn([4,1],70)| (or |scc(4)_dn([4,1],70)|))) -(assert (= |dn([6,9],94)| (or |dn([6,9],93)_dn([6,9],94)|))) -(assert (= |dn([8,Main.main],100)| (or |scc(5)_dn([8,Main.main],100)|))) -(assert (= |dn([7,Main.main],59)| (or |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (= |dn([5,1],61)| (or |dn([1,3],67)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (= |dn([4,1],69)| (or |dn([1,3],65)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (= |dn([3,7],29)| (or |scc(6)_dn([3,7],29)| |scc(2)_dn([3,7],29)| |scc(3)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (= |dn([3,7],31)| (or |dn([2,3],36)_dn([3,7],31)| |scc(2)_dn([3,7],31)| |scc(3)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (= |dn([4,1],79)| (or |dn([4,1],78)_dn([4,1],79)|))) -(assert (= |dn([2,3],34)| (or |scc(0)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],34)| |scc(0)_dn([2,3],34)|))) -(assert (= |dn([Main.main],115)| (or |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (= |dn([2,3],37)| (or |dn([2,3],36)_dn([2,3],37)|))) -(assert (= |dn([1,3],68)| (or |dn([1,3],67)_dn([1,3],68)|))) -(assert (= |dn([4,1],81)| (or |dn([4,1],80)_dn([4,1],81)|))) -(assert (= |scc(7)| (or |dn([9,Main.main],87)_scc(7)| |scc(1)_scc(7)| |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (= |dn([9,Main.main],89)| (or |dn([9,Main.main],88)_dn([9,Main.main],89)|))) -(assert (= |dn([1,3],66)| (or |dn([1,3],65)_dn([1,3],66)|))) -(assert (= |dn([9,Main.main],84)| (or |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],65)| (or |dn([3,7],22)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (= |dn([7,Main.main],43)| (or |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (= |dn([9,Main.main],82)| (or |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (= |dn([7,Main.main],45)| (or |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (= |dn([3,7],30)| (or |dn([3,7],29)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not |scc(8)|)) -(assert (= |dn([9,Main.main],87)| (or |dn([9,Main.main],86)_dn([9,Main.main],87)|))) -(assert (= |dn([3,7],21)| (or |dn([3,7],20)_dn([3,7],21)|))) -(assert (= |dn([7,Main.main],49)| (or |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (= |scc(6)| (or |dn([3,7],28)_scc(6)|))) -(assert-soft |dn([7,Main.main],41)_dn([3,7],20)| :weight 1) -(assert-soft |scc(2)_dn([3,7],20)| :weight 1) -(assert-soft |scc(3)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],20)_dn([3,7],21)| :weight 1) -(assert-soft |dn([7,Main.main],42)_dn([3,7],22)| :weight 1) -(assert-soft |scc(2)_dn([3,7],22)| :weight 1) -(assert-soft |scc(3)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],22)| :weight 1) -(assert-soft |scc(0)_dn([3,7],24)| :weight 1) -(assert-soft |dn([3,7],24)_dn([3,7],25)| :weight 1) -(assert-soft |dn([8,Main.main],97)_dn([3,7],27)| :weight 2) -(assert-soft |scc(2)_dn([3,7],27)| :weight 2) -(assert-soft |scc(3)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],21)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],28)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],30)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],33)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],29)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],27)_dn([3,7],28)| :weight 6) -(assert-soft |dn([3,7],29)_dn([3,7],28)| :weight 6) -(assert-soft |scc(6)_dn([3,7],29)| :weight 2) -(assert-soft |scc(2)_dn([3,7],29)| :weight 2) -(assert-soft |scc(3)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],21)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],28)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],30)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],33)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],27)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],29)_dn([3,7],30)| :weight 6) -(assert-soft |dn([3,7],27)_dn([3,7],30)| :weight 6) -(assert-soft |dn([2,3],36)_dn([3,7],31)| :weight 1) -(assert-soft |scc(2)_dn([3,7],31)| :weight 1) -(assert-soft |scc(3)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],31)| :weight 1) -(assert-soft |dn([2,3],35)_dn([3,7],33)| :weight 1) -(assert-soft |scc(2)_dn([3,7],33)| :weight 1) -(assert-soft |scc(3)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],33)| :weight 1) -(assert-soft |scc(0)_dn([2,3],34)| :weight 1) -(assert-soft |dn([2,3],38)_dn([2,3],34)| :weight 1) -(assert-soft |scc(4)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],34)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],38)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],35)_dn([2,3],36)| :weight 1) -(assert-soft |dn([2,3],36)_dn([2,3],37)| :weight 1) -(assert-soft |dn([2,3],37)_dn([2,3],38)| :weight 1) -(assert-soft |dn([Main.main],103)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],39)| :weight 6) -(assert-soft |scc(1)_dn([7,Main.main],39)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],43)_dn([7,Main.main],40)| :weight 4) -(assert-soft |dn([7,Main.main],45)_dn([7,Main.main],40)| :weight 4) -(assert-soft |dn([7,Main.main],47)_dn([7,Main.main],41)| :weight 1) -(assert-soft |dn([7,Main.main],41)_dn([7,Main.main],42)| :weight 1) -(assert-soft |dn([7,Main.main],42)_dn([7,Main.main],43)| :weight 1) -(assert-soft |dn([7,Main.main],47)_dn([7,Main.main],45)| :weight 4) -(assert-soft |dn([Main.main],106)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],47)| :weight 8) -(assert-soft |scc(1)_dn([7,Main.main],47)| :weight 8) -(assert-soft |scc(7)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([Main.main],104)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],49)| :weight 8) -(assert-soft |scc(1)_dn([7,Main.main],49)| :weight 8) -(assert-soft |scc(7)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([Main.main],105)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],50)| :weight 2) -(assert-soft |scc(1)_dn([7,Main.main],50)| :weight 2) -(assert-soft |scc(7)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],51)| :weight 6) -(assert-soft |scc(1)_dn([7,Main.main],51)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([9,Main.main],87)_dn([7,Main.main],53)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],53)| :weight 6) -(assert-soft |dn([6,9],91)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],54)| :weight 2) -(assert-soft |scc(1)_dn([7,Main.main],54)| :weight 2) -(assert-soft |scc(7)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(1)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(7)_dn([7,Main.main],55)| :weight 18) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],55)| :weight 18) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(1)_dn([7,Main.main],57)| :weight 4) -(assert-soft |dn([2,3],37)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],58)| :weight 1) -(assert-soft |scc(1)_dn([7,Main.main],58)| :weight 1) -(assert-soft |scc(7)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],59)| :weight 1) -(assert-soft |scc(1)_dn([7,Main.main],59)| :weight 1) -(assert-soft |scc(7)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],59)_dn([7,Main.main],60)| :weight 1) -(assert-soft |dn([1,3],67)_dn([5,1],61)| :weight 1) -(assert-soft |dn([5,1],62)_dn([5,1],61)| :weight 1) -(assert-soft |dn([5,1],63)_dn([5,1],61)| :weight 1) -(assert-soft |dn([3,7],31)_dn([5,1],62)| :weight 1) -(assert-soft |dn([5,1],61)_dn([5,1],62)| :weight 1) -(assert-soft |dn([5,1],63)_dn([5,1],62)| :weight 1) -(assert-soft |scc(5)_dn([5,1],63)| :weight 8) -(assert-soft |dn([5,1],61)_dn([5,1],63)| :weight 8) -(assert-soft |dn([5,1],62)_dn([5,1],63)| :weight 8) -(assert-soft |dn([3,7],20)_dn([1,3],64)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],64)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],64)| :weight 1) -(assert-soft |dn([3,7],22)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],64)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],65)_dn([1,3],66)| :weight 1) -(assert-soft |dn([3,7],25)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],64)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],67)_dn([1,3],68)| :weight 1) -(assert-soft |dn([1,3],65)_dn([4,1],69)| :weight 1) -(assert-soft |dn([4,1],79)_dn([4,1],69)| :weight 1) -(assert-soft |dn([4,1],81)_dn([4,1],69)| :weight 1) -(assert-soft |scc(4)_dn([4,1],70)| :weight 2) -(assert-soft |dn([8,Main.main],100)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],69)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],79)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],81)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],78)_dn([4,1],79)| :weight 4) -(assert-soft |dn([3,7],24)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],69)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],79)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],81)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],80)_dn([4,1],81)| :weight 1) -(assert-soft |dn([Main.main],113)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([Main.main],114)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([7,Main.main],51)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],85)| :weight 6) -(assert-soft |dn([9,Main.main],85)_dn([9,Main.main],86)| :weight 6) -(assert-soft |dn([9,Main.main],86)_dn([9,Main.main],87)| :weight 2) -(assert-soft |dn([6,9],93)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],88)_dn([9,Main.main],89)| :weight 6) -(assert-soft |dn([9,Main.main],85)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],92)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],94)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],95)_dn([6,9],90)| :weight 8) -(assert-soft |dn([9,Main.main],86)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],90)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],92)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],94)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],95)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],91)_dn([6,9],92)| :weight 4) -(assert-soft |scc(1)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],90)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],92)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],94)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],95)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],93)_dn([6,9],94)| :weight 4) -(assert-soft |dn([7,Main.main],55)_dn([6,9],95)| :weight 6) -(assert-soft |dn([7,Main.main],59)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],90)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],92)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],94)_dn([6,9],95)| :weight 6) -(assert-soft |scc(8)_dn([8,Main.main],96)| :weight 4) -(assert-soft |dn([8,Main.main],101)_dn([8,Main.main],96)| :weight 4) -(assert-soft |dn([Main.main],108)_dn([8,Main.main],97)| :weight 8) -(assert-soft |dn([8,Main.main],96)_dn([8,Main.main],97)| :weight 8) -(assert-soft |dn([8,Main.main],101)_dn([8,Main.main],97)| :weight 8) -(assert-soft |scc(5)_dn([8,Main.main],100)| :weight 4) -(assert-soft |dn([8,Main.main],100)_dn([8,Main.main],101)| :weight 4) -(assert-soft |dn([Main.main],111)_dn([Main.main],102)| :weight 1) -(assert-soft |dn([Main.main],111)_dn([Main.main],103)| :weight 6) -(assert-soft |dn([Main.main],103)_dn([Main.main],104)| :weight 2) -(assert-soft |dn([Main.main],104)_dn([Main.main],105)| :weight 2) -(assert-soft |dn([Main.main],105)_dn([Main.main],106)| :weight 2) -(assert-soft |scc(8)_dn([Main.main],108)| :weight 2) -(assert-soft |dn([Main.main],108)_dn([Main.main],109)| :weight 6) -(assert-soft |dn([Main.main],109)_dn([Main.main],111)| :weight 6) -(assert-soft |dn([Main.main],115)_dn([Main.main],111)| :weight 6) -(assert-soft |dn([Main.main],116)_dn([Main.main],113)| :weight 3) -(assert-soft |dn([Main.main],113)_dn([Main.main],114)| :weight 1) -(assert-soft |dn([Main.main],114)_dn([Main.main],115)| :weight 1) -(assert-soft |dn([Main.main],115)_dn([Main.main],116)| :weight 2) -(assert-soft |dn([1,3],66)_scc(0)| :weight 1) -(assert-soft |dn([6,9],95)_scc(1)| :weight 6) -(assert-soft |scc(7)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],50)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],54)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],58)_scc(1)| :weight 6) -(assert-soft |dn([5,1],62)_scc(2)| :weight 1) -(assert-soft |dn([4,1],78)_scc(4)| :weight 4) -(assert-soft |dn([3,7],30)_scc(5)| :weight 8) -(assert-soft |dn([3,7],28)_scc(6)| :weight 6) -(assert-soft |dn([9,Main.main],87)_scc(7)| :weight 2) -(assert-soft |scc(1)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],50)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],54)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],58)_scc(7)| :weight 2) -(optimize -; :wmaxsat_engine wpm2 -; :wmaxsat_engine pwmax -; :wmaxsat_engine bvmax - :print_statistics true - :timeout 1200000 -) diff --git a/tests/chat_pb.smt2 b/tests/chat_pb.smt2 deleted file mode 100644 index 8f32a632872..00000000000 --- a/tests/chat_pb.smt2 +++ /dev/null @@ -1,3382 +0,0 @@ -(declare-const |dn([7,Main.main],41)| Bool) -(declare-const |dn([3,7],24)| Bool) -(declare-const |dn([7,Main.main],47)| Bool) -(declare-const |dn([9,Main.main],86)| Bool) -(declare-const |dn([7,Main.main],51)| Bool) -(declare-const |dn([3,7],20)| Bool) -(declare-const |dn([6,9],91)| Bool) -(declare-const |scc(3)| Bool) -(declare-const |dn([6,9],92)| Bool) -(declare-const |scc(4)| Bool) -(declare-const |dn([7,Main.main],54)| Bool) -(declare-const |scc(0)| Bool) -(declare-const |dn([Main.main],109)| Bool) -(declare-const |dn([7,Main.main],58)| Bool) -(declare-const |dn([Main.main],104)| Bool) -(declare-const |dn([Main.main],102)| Bool) -(declare-const |dn([8,Main.main],101)| Bool) -(declare-const |dn([6,9],95)| Bool) -(declare-const |dn([8,Main.main],96)| Bool) -(declare-const |dn([3,7],28)| Bool) -(declare-const |dn([Main.main],106)| Bool) -(declare-const |dn([2,3],36)| Bool) -(declare-const |dn([4,1],78)| Bool) -(declare-const |dn([Main.main],114)| Bool) -(declare-const |dn([2,3],35)| Bool) -(declare-const |dn([2,3],38)| Bool) -(declare-const |dn([5,1],63)| Bool) -(declare-const |dn([7,Main.main],39)| Bool) -(declare-const |dn([3,7],33)| Bool) -(declare-const |dn([9,Main.main],88)| Bool) -(declare-const |dn([4,1],80)| Bool) -(declare-const |dn([Main.main],116)| Bool) -(declare-const |dn([Main.main],111)| Bool) -(declare-const |dn([7,Main.main],42)| Bool) -(declare-const |dn([9,Main.main],85)| Bool) -(declare-const |dn([3,7],27)| Bool) -(declare-const |dn([1,3],64)| Bool) -(declare-const |dn([9,Main.main],83)| Bool) -(declare-const |dn([1,3],67)| Bool) -(declare-const |dn([7,Main.main],40)| Bool) -(declare-const |dn([3,7],25)| Bool) -(declare-const |dn([6,9],90)| Bool) -(declare-const |dn([7,Main.main],60)| Bool) -(declare-const |dn([7,Main.main],50)| Bool) -(declare-const |dn([5,1],62)| Bool) -(declare-const |dn([3,7],22)| Bool) -(declare-const |dn([7,Main.main],53)| Bool) -(declare-const |dn([6,9],93)| Bool) -(declare-const |dn([7,Main.main],57)| Bool) -(declare-const |dn([Main.main],108)| Bool) -(declare-const |dn([7,Main.main],55)| Bool) -(declare-const |scc(1)| Bool) -(declare-const |dn([Main.main],105)| Bool) -(declare-const |scc(2)| Bool) -(declare-const |dn([8,Main.main],97)| Bool) -(declare-const |dn([Main.main],103)| Bool) -(declare-const |scc(5)| Bool) -(declare-const |dn([4,1],70)| Bool) -(declare-const |dn([6,9],94)| Bool) -(declare-const |dn([8,Main.main],100)| Bool) -(declare-const |dn([7,Main.main],59)| Bool) -(declare-const |dn([5,1],61)| Bool) -(declare-const |dn([4,1],69)| Bool) -(declare-const |dn([3,7],29)| Bool) -(declare-const |dn([3,7],31)| Bool) -(declare-const |dn([Main.main],113)| Bool) -(declare-const |dn([4,1],79)| Bool) -(declare-const |dn([2,3],34)| Bool) -(declare-const |dn([Main.main],115)| Bool) -(declare-const |dn([2,3],37)| Bool) -(declare-const |dn([1,3],68)| Bool) -(declare-const |dn([4,1],81)| Bool) -(declare-const |scc(7)| Bool) -(declare-const |dn([9,Main.main],89)| Bool) -(declare-const |dn([1,3],66)| Bool) -(declare-const |dn([9,Main.main],84)| Bool) -(declare-const |dn([1,3],65)| Bool) -(declare-const |dn([7,Main.main],43)| Bool) -(declare-const |dn([9,Main.main],82)| Bool) -(declare-const |dn([7,Main.main],45)| Bool) -(declare-const |dn([3,7],30)| Bool) -(declare-const |scc(8)| Bool) -(declare-const |dn([9,Main.main],87)| Bool) -(declare-const |dn([3,7],21)| Bool) -(declare-const |dn([7,Main.main],49)| Bool) -(declare-const |scc(6)| Bool) -(declare-const |dn([7,Main.main],41)_dn([3,7],20)| Bool) -(declare-const |dn([7,Main.main],41)_dn([7,Main.main],42)| Bool) -(declare-const |dn([3,7],24)_dn([3,7],25)| Bool) -(declare-const |dn([3,7],24)_dn([4,1],80)| Bool) -(declare-const |dn([7,Main.main],47)_dn([7,Main.main],41)| Bool) -(declare-const |dn([7,Main.main],47)_dn([7,Main.main],45)| Bool) -(declare-const |dn([9,Main.main],86)_dn([9,Main.main],87)| Bool) -(declare-const |dn([9,Main.main],86)_dn([6,9],91)| Bool) -(declare-const |dn([7,Main.main],51)_dn([9,Main.main],84)| Bool) -(declare-const |dn([3,7],20)_dn([3,7],21)| Bool) -(declare-const |dn([3,7],20)_dn([1,3],64)| Bool) -(declare-const |dn([6,9],91)_dn([7,Main.main],54)| Bool) -(declare-const |dn([6,9],91)_dn([6,9],92)| Bool) -(declare-const |scc(3)_dn([3,7],20)| Bool) -(declare-const |scc(3)_dn([3,7],22)| Bool) -(declare-const |scc(3)_dn([3,7],27)| Bool) -(declare-const |scc(3)_dn([3,7],29)| Bool) -(declare-const |scc(3)_dn([3,7],31)| Bool) -(declare-const |scc(3)_dn([3,7],33)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],95)| Bool) -(declare-const |scc(4)_dn([2,3],35)| Bool) -(declare-const |scc(4)_dn([4,1],70)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],54)_scc(1)| Bool) -(declare-const |dn([7,Main.main],54)_scc(7)| Bool) -(declare-const |scc(0)_dn([3,7],24)| Bool) -(declare-const |scc(0)_dn([2,3],34)| Bool) -(declare-const |dn([Main.main],109)_dn([Main.main],111)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],58)_scc(1)| Bool) -(declare-const |dn([7,Main.main],58)_scc(7)| Bool) -(declare-const |dn([Main.main],104)_dn([7,Main.main],49)| Bool) -(declare-const |dn([Main.main],104)_dn([Main.main],105)| Bool) -(declare-const |dn([8,Main.main],101)_dn([8,Main.main],96)| Bool) -(declare-const |dn([8,Main.main],101)_dn([8,Main.main],97)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],95)_scc(1)| Bool) -(declare-const |dn([8,Main.main],96)_dn([8,Main.main],97)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],28)_scc(6)| Bool) -(declare-const |dn([Main.main],106)_dn([7,Main.main],47)| Bool) -(declare-const |dn([2,3],36)_dn([3,7],31)| Bool) -(declare-const |dn([2,3],36)_dn([2,3],37)| Bool) -(declare-const |dn([4,1],78)_dn([4,1],79)| Bool) -(declare-const |dn([4,1],78)_scc(4)| Bool) -(declare-const |dn([Main.main],114)_dn([9,Main.main],83)| Bool) -(declare-const |dn([Main.main],114)_dn([Main.main],115)| Bool) -(declare-const |dn([2,3],35)_dn([3,7],33)| Bool) -(declare-const |dn([2,3],35)_dn([2,3],36)| Bool) -(declare-const |dn([2,3],38)_dn([2,3],34)| Bool) -(declare-const |dn([2,3],38)_dn([2,3],35)| Bool) -(declare-const |dn([5,1],63)_dn([5,1],61)| Bool) -(declare-const |dn([5,1],63)_dn([5,1],62)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],58)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],31)| Bool) -(declare-const |dn([9,Main.main],88)_dn([9,Main.main],89)| Bool) -(declare-const |dn([4,1],80)_dn([4,1],81)| Bool) -(declare-const |dn([Main.main],116)_dn([Main.main],113)| Bool) -(declare-const |dn([Main.main],111)_dn([Main.main],102)| Bool) -(declare-const |dn([Main.main],111)_dn([Main.main],103)| Bool) -(declare-const |dn([7,Main.main],42)_dn([3,7],22)| Bool) -(declare-const |dn([7,Main.main],42)_dn([7,Main.main],43)| Bool) -(declare-const |dn([9,Main.main],85)_dn([9,Main.main],86)| Bool) -(declare-const |dn([9,Main.main],85)_dn([6,9],90)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],28)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],30)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],33)| Bool) -(declare-const |dn([1,3],64)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],64)_dn([1,3],67)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],67)_dn([5,1],61)| Bool) -(declare-const |dn([1,3],67)_dn([1,3],68)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],58)| Bool) -(declare-const |dn([3,7],25)_dn([1,3],67)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],95)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],50)_scc(1)| Bool) -(declare-const |dn([7,Main.main],50)_scc(7)| Bool) -(declare-const |dn([5,1],62)_dn([5,1],61)| Bool) -(declare-const |dn([5,1],62)_dn([5,1],63)| Bool) -(declare-const |dn([5,1],62)_scc(2)| Bool) -(declare-const |dn([3,7],22)_dn([1,3],65)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],58)| Bool) -(declare-const |dn([6,9],93)_dn([9,Main.main],88)| Bool) -(declare-const |dn([6,9],93)_dn([6,9],94)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],58)| Bool) -(declare-const |dn([Main.main],108)_dn([8,Main.main],97)| Bool) -(declare-const |dn([Main.main],108)_dn([Main.main],109)| Bool) -(declare-const |dn([7,Main.main],55)_dn([6,9],95)| Bool) -(declare-const |scc(1)_dn([7,Main.main],39)| Bool) -(declare-const |scc(1)_dn([7,Main.main],47)| Bool) -(declare-const |scc(1)_dn([7,Main.main],49)| Bool) -(declare-const |scc(1)_dn([7,Main.main],50)| Bool) -(declare-const |scc(1)_dn([7,Main.main],51)| Bool) -(declare-const |scc(1)_dn([7,Main.main],54)| Bool) -(declare-const |scc(1)_dn([7,Main.main],55)| Bool) -(declare-const |scc(1)_dn([7,Main.main],57)| Bool) -(declare-const |scc(1)_dn([7,Main.main],58)| Bool) -(declare-const |scc(1)_dn([7,Main.main],59)| Bool) -(declare-const |scc(1)_dn([6,9],93)| Bool) -(declare-const |scc(1)_scc(7)| Bool) -(declare-const |dn([Main.main],105)_dn([7,Main.main],50)| Bool) -(declare-const |dn([Main.main],105)_dn([Main.main],106)| Bool) -(declare-const |scc(2)_dn([3,7],20)| Bool) -(declare-const |scc(2)_dn([3,7],22)| Bool) -(declare-const |scc(2)_dn([3,7],27)| Bool) -(declare-const |scc(2)_dn([3,7],29)| Bool) -(declare-const |scc(2)_dn([3,7],31)| Bool) -(declare-const |scc(2)_dn([3,7],33)| Bool) -(declare-const |dn([8,Main.main],97)_dn([3,7],27)| Bool) -(declare-const |dn([Main.main],103)_dn([7,Main.main],39)| Bool) -(declare-const |dn([Main.main],103)_dn([Main.main],104)| Bool) -(declare-const |scc(5)_dn([5,1],63)| Bool) -(declare-const |scc(5)_dn([8,Main.main],100)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],95)| Bool) -(declare-const |dn([8,Main.main],100)_dn([4,1],78)| Bool) -(declare-const |dn([8,Main.main],100)_dn([8,Main.main],101)| Bool) -(declare-const |dn([7,Main.main],59)_dn([7,Main.main],60)| Bool) -(declare-const |dn([7,Main.main],59)_dn([6,9],95)| Bool) -(declare-const |dn([5,1],61)_dn([5,1],62)| Bool) -(declare-const |dn([5,1],61)_dn([5,1],63)| Bool) -(declare-const |dn([4,1],69)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],69)_dn([4,1],80)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],28)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],30)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],31)_dn([5,1],62)| Bool) -(declare-const |dn([Main.main],113)_dn([9,Main.main],82)| Bool) -(declare-const |dn([Main.main],113)_dn([Main.main],114)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],69)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],80)| Bool) -(declare-const |dn([2,3],34)_dn([2,3],35)| Bool) -(declare-const |dn([Main.main],115)_dn([Main.main],111)| Bool) -(declare-const |dn([Main.main],115)_dn([Main.main],116)| Bool) -(declare-const |dn([2,3],37)_dn([2,3],38)| Bool) -(declare-const |dn([2,3],37)_dn([7,Main.main],58)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],64)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],67)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],69)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],80)| Bool) -(declare-const |scc(7)_dn([7,Main.main],39)| Bool) -(declare-const |scc(7)_dn([7,Main.main],47)| Bool) -(declare-const |scc(7)_dn([7,Main.main],49)| Bool) -(declare-const |scc(7)_dn([7,Main.main],50)| Bool) -(declare-const |scc(7)_dn([7,Main.main],51)| Bool) -(declare-const |scc(7)_dn([7,Main.main],53)| Bool) -(declare-const |scc(7)_dn([7,Main.main],54)| Bool) -(declare-const |scc(7)_dn([7,Main.main],55)| Bool) -(declare-const |scc(7)_dn([7,Main.main],58)| Bool) -(declare-const |scc(7)_dn([7,Main.main],59)| Bool) -(declare-const |scc(7)_scc(1)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],64)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],67)| Bool) -(declare-const |dn([1,3],66)_scc(0)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],85)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],65)_dn([1,3],66)| Bool) -(declare-const |dn([1,3],65)_dn([4,1],69)| Bool) -(declare-const |dn([7,Main.main],43)_dn([7,Main.main],40)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],88)| Bool) -(declare-const |dn([7,Main.main],45)_dn([7,Main.main],40)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],30)_scc(5)| Bool) -(declare-const |scc(8)_dn([8,Main.main],96)| Bool) -(declare-const |scc(8)_dn([Main.main],108)| Bool) -(declare-const |dn([9,Main.main],87)_dn([7,Main.main],53)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],88)| Bool) -(declare-const |dn([9,Main.main],87)_scc(7)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],33)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],58)| Bool) -(declare-const |scc(6)_dn([3,7],29)| Bool) -(assert |dn([Main.main],113)|) -(assert (= |dn([7,Main.main],41)| (or |dn([7,Main.main],41)_dn([3,7],20)| |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (not (and |dn([7,Main.main],41)_dn([7,Main.main],42)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (= |dn([3,7],24)| (or |dn([3,7],24)_dn([3,7],25)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([3,7],25)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([3,7],24)_dn([3,7],25)|))) -(assert (= |dn([7,Main.main],47)| (or |dn([7,Main.main],47)_dn([7,Main.main],41)| |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (not (and |dn([7,Main.main],47)_dn([7,Main.main],41)| |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (not (and |dn([7,Main.main],47)_dn([7,Main.main],45)| |dn([7,Main.main],47)_dn([7,Main.main],41)|))) -(assert (= |dn([9,Main.main],86)| (or |dn([9,Main.main],86)_dn([9,Main.main],87)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([9,Main.main],87)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([9,Main.main],86)_dn([9,Main.main],87)|))) -(assert (= |dn([7,Main.main],51)| (or |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (= |dn([3,7],20)| (or |dn([3,7],20)_dn([3,7],21)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([3,7],21)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([3,7],20)_dn([3,7],21)|))) -(assert (= |dn([6,9],91)| (or |dn([6,9],91)_dn([7,Main.main],54)| |dn([6,9],91)_dn([6,9],92)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([6,9],91)_dn([6,9],92)|))) -(assert (not (and |dn([6,9],91)_dn([6,9],92)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (= |scc(3)| (or |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],31)|))) -(assert (= |dn([6,9],92)| (or |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (= |scc(4)| (or |scc(4)_dn([2,3],35)| |scc(4)_dn([4,1],70)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |scc(4)_dn([4,1],70)|))) -(assert (not (and |scc(4)_dn([4,1],70)| |scc(4)_dn([2,3],35)|))) -(assert (= |dn([7,Main.main],54)| (or |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_scc(1)|))) -(assert (= |scc(0)| (or |scc(0)_dn([3,7],24)| |scc(0)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([3,7],24)| |scc(0)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([2,3],34)| |scc(0)_dn([3,7],24)|))) -(assert (= |dn([Main.main],109)| (or |dn([Main.main],109)_dn([Main.main],111)|))) -(assert (= |dn([7,Main.main],58)| (or |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_scc(1)|))) -(assert (= |dn([Main.main],104)| (or |dn([Main.main],104)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (not (and |dn([Main.main],104)_dn([Main.main],105)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not |dn([Main.main],102)|)) -(assert (= |dn([8,Main.main],101)| (or |dn([8,Main.main],101)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (= |dn([6,9],95)| (or |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (= |dn([8,Main.main],96)| (or |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (= |dn([3,7],28)| (or |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (= |dn([Main.main],106)| (or |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (= |dn([2,3],36)| (or |dn([2,3],36)_dn([3,7],31)| |dn([2,3],36)_dn([2,3],37)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([2,3],36)_dn([2,3],37)|))) -(assert (not (and |dn([2,3],36)_dn([2,3],37)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (= |dn([4,1],78)| (or |dn([4,1],78)_dn([4,1],79)| |dn([4,1],78)_scc(4)|))) -(assert (not (and |dn([4,1],78)_dn([4,1],79)| |dn([4,1],78)_scc(4)|))) -(assert (not (and |dn([4,1],78)_scc(4)| |dn([4,1],78)_dn([4,1],79)|))) -(assert (= |dn([Main.main],114)| (or |dn([Main.main],114)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (not (and |dn([Main.main],114)_dn([Main.main],115)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (= |dn([2,3],35)| (or |dn([2,3],35)_dn([3,7],33)| |dn([2,3],35)_dn([2,3],36)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([2,3],35)_dn([2,3],36)|))) -(assert (not (and |dn([2,3],35)_dn([2,3],36)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (= |dn([2,3],38)| (or |dn([2,3],38)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (= |dn([5,1],63)| (or |dn([5,1],63)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (= |dn([7,Main.main],39)| (or |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (= |dn([3,7],33)| (or |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (= |dn([9,Main.main],88)| (or |dn([9,Main.main],88)_dn([9,Main.main],89)|))) -(assert (= |dn([4,1],80)| (or |dn([4,1],80)_dn([4,1],81)|))) -(assert (= |dn([Main.main],116)| (or |dn([Main.main],116)_dn([Main.main],113)|))) -(assert (= |dn([Main.main],111)| (or |dn([Main.main],111)_dn([Main.main],102)| |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (not (and |dn([Main.main],111)_dn([Main.main],102)| |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (not (and |dn([Main.main],111)_dn([Main.main],103)| |dn([Main.main],111)_dn([Main.main],102)|))) -(assert (= |dn([7,Main.main],42)| (or |dn([7,Main.main],42)_dn([3,7],22)| |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (not (and |dn([7,Main.main],42)_dn([7,Main.main],43)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (= |dn([9,Main.main],85)| (or |dn([9,Main.main],85)_dn([9,Main.main],86)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([9,Main.main],86)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([9,Main.main],85)_dn([9,Main.main],86)|))) -(assert (= |dn([3,7],27)| (or |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (= |dn([1,3],64)| (or |dn([1,3],64)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (= |dn([9,Main.main],83)| (or |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],67)| (or |dn([1,3],67)_dn([5,1],61)| |dn([1,3],67)_dn([1,3],68)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([1,3],67)_dn([1,3],68)|))) -(assert (not (and |dn([1,3],67)_dn([1,3],68)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (= |dn([7,Main.main],40)| (or |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (= |dn([3,7],25)| (or |dn([3,7],25)_dn([1,3],67)|))) -(assert (= |dn([6,9],90)| (or |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (= |dn([7,Main.main],60)| (or |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (= |dn([7,Main.main],50)| (or |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_scc(1)|))) -(assert (= |dn([5,1],62)| (or |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_scc(2)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_scc(2)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (= |dn([3,7],22)| (or |dn([3,7],22)_dn([1,3],65)|))) -(assert (= |dn([7,Main.main],53)| (or |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (= |dn([6,9],93)| (or |dn([6,9],93)_dn([9,Main.main],88)| |dn([6,9],93)_dn([6,9],94)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([6,9],93)_dn([6,9],94)|))) -(assert (not (and |dn([6,9],93)_dn([6,9],94)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (= |dn([7,Main.main],57)| (or |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (= |dn([Main.main],108)| (or |dn([Main.main],108)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (not (and |dn([Main.main],108)_dn([Main.main],109)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (= |dn([7,Main.main],55)| (or |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (= |scc(1)| (or |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([6,9],93)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([6,9],93)|))) -(assert (= |dn([Main.main],105)| (or |dn([Main.main],105)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (not (and |dn([Main.main],105)_dn([Main.main],106)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (= |scc(2)| (or |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],31)|))) -(assert (= |dn([8,Main.main],97)| (or |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (= |dn([Main.main],103)| (or |dn([Main.main],103)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (not (and |dn([Main.main],103)_dn([Main.main],104)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (= |scc(5)| (or |scc(5)_dn([5,1],63)| |scc(5)_dn([8,Main.main],100)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |scc(5)_dn([8,Main.main],100)|))) -(assert (not (and |scc(5)_dn([8,Main.main],100)| |scc(5)_dn([5,1],63)|))) -(assert (not |dn([4,1],70)|)) -(assert (= |dn([6,9],94)| (or |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (= |dn([8,Main.main],100)| (or |dn([8,Main.main],100)_dn([4,1],78)| |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (not (and |dn([8,Main.main],100)_dn([8,Main.main],101)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (= |dn([7,Main.main],59)| (or |dn([7,Main.main],59)_dn([7,Main.main],60)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([7,Main.main],60)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([7,Main.main],59)_dn([7,Main.main],60)|))) -(assert (= |dn([5,1],61)| (or |dn([5,1],61)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (= |dn([4,1],69)| (or |dn([4,1],69)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (= |dn([3,7],29)| (or |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (= |dn([3,7],31)| (or |dn([3,7],31)_dn([5,1],62)|))) -(assert (= |dn([Main.main],113)| (or |dn([Main.main],113)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (not (and |dn([Main.main],113)_dn([Main.main],114)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (= |dn([4,1],79)| (or |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (= |dn([2,3],34)| (or |dn([2,3],34)_dn([2,3],35)|))) -(assert (= |dn([Main.main],115)| (or |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],116)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (= |dn([2,3],37)| (or |dn([2,3],37)_dn([2,3],38)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([2,3],38)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([2,3],37)_dn([2,3],38)|))) -(assert (= |dn([1,3],68)| (or |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (= |dn([4,1],81)| (or |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (= |scc(7)| (or |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],59)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],59)|))) -(assert (= |dn([9,Main.main],89)| (or |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],66)| (or |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (= |dn([9,Main.main],84)| (or |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (= |dn([1,3],65)| (or |dn([1,3],65)_dn([1,3],66)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([1,3],66)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([1,3],65)_dn([1,3],66)|))) -(assert (= |dn([7,Main.main],43)| (or |dn([7,Main.main],43)_dn([7,Main.main],40)|))) -(assert (= |dn([9,Main.main],82)| (or |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (= |dn([7,Main.main],45)| (or |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (= |dn([3,7],30)| (or |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (= |scc(8)| (or |scc(8)_dn([8,Main.main],96)| |scc(8)_dn([Main.main],108)|))) -(assert (not (and |scc(8)_dn([8,Main.main],96)| |scc(8)_dn([Main.main],108)|))) -(assert (not (and |scc(8)_dn([Main.main],108)| |scc(8)_dn([8,Main.main],96)|))) -(assert (= |dn([9,Main.main],87)| (or |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (= |dn([7,Main.main],49)| (or |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (= |scc(6)| (or |scc(6)_dn([3,7],29)|))) -(assert (= |dn([7,Main.main],41)| (or |dn([7,Main.main],47)_dn([7,Main.main],41)|))) -(assert (= |dn([3,7],24)| (or |scc(0)_dn([3,7],24)|))) -(assert (= |dn([7,Main.main],47)| (or |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (= |dn([9,Main.main],86)| (or |dn([9,Main.main],85)_dn([9,Main.main],86)|))) -(assert (= |dn([7,Main.main],51)| (or |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (= |dn([3,7],20)| (or |dn([7,Main.main],41)_dn([3,7],20)| |scc(2)_dn([3,7],20)| |scc(3)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (= |dn([6,9],91)| (or |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not |scc(3)|)) -(assert (= |dn([6,9],92)| (or |dn([6,9],91)_dn([6,9],92)|))) -(assert (= |scc(4)| (or |dn([4,1],78)_scc(4)|))) -(assert (= |dn([7,Main.main],54)| (or |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (= |scc(0)| (or |dn([1,3],66)_scc(0)|))) -(assert (= |dn([Main.main],109)| (or |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (= |dn([7,Main.main],58)| (or |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (= |dn([Main.main],104)| (or |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (= |dn([Main.main],102)| (or |dn([Main.main],111)_dn([Main.main],102)|))) -(assert (= |dn([8,Main.main],101)| (or |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (= |dn([6,9],95)| (or |dn([7,Main.main],55)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (= |dn([8,Main.main],96)| (or |scc(8)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (not (and |scc(8)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],96)| |scc(8)_dn([8,Main.main],96)|))) -(assert (= |dn([3,7],28)| (or |dn([3,7],27)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (= |dn([Main.main],106)| (or |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (= |dn([2,3],36)| (or |dn([2,3],35)_dn([2,3],36)|))) -(assert (= |dn([4,1],78)| (or |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (= |dn([Main.main],114)| (or |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (= |dn([2,3],35)| (or |scc(4)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],34)_dn([2,3],35)| |scc(4)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],34)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |scc(4)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)|))) -(assert (= |dn([2,3],38)| (or |dn([2,3],37)_dn([2,3],38)|))) -(assert (= |dn([5,1],63)| (or |scc(5)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |scc(5)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |scc(5)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (= |dn([7,Main.main],39)| (or |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (= |dn([3,7],33)| (or |dn([2,3],35)_dn([3,7],33)| |scc(2)_dn([3,7],33)| |scc(3)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (= |dn([9,Main.main],88)| (or |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (= |dn([4,1],80)| (or |dn([3,7],24)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (= |dn([Main.main],116)| (or |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (= |dn([Main.main],111)| (or |dn([Main.main],109)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (not (and |dn([Main.main],109)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],109)_dn([Main.main],111)|))) -(assert (= |dn([7,Main.main],42)| (or |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (= |dn([9,Main.main],85)| (or |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (= |dn([3,7],27)| (or |dn([8,Main.main],97)_dn([3,7],27)| |scc(2)_dn([3,7],27)| |scc(3)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (= |dn([1,3],64)| (or |dn([3,7],20)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (= |dn([9,Main.main],83)| (or |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (= |dn([1,3],67)| (or |dn([3,7],25)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (= |dn([7,Main.main],40)| (or |dn([7,Main.main],43)_dn([7,Main.main],40)| |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (not (and |dn([7,Main.main],43)_dn([7,Main.main],40)| |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (not (and |dn([7,Main.main],45)_dn([7,Main.main],40)| |dn([7,Main.main],43)_dn([7,Main.main],40)|))) -(assert (= |dn([3,7],25)| (or |dn([3,7],24)_dn([3,7],25)|))) -(assert (= |dn([6,9],90)| (or |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (= |dn([7,Main.main],60)| (or |dn([7,Main.main],59)_dn([7,Main.main],60)|))) -(assert (= |dn([7,Main.main],50)| (or |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (= |dn([5,1],62)| (or |dn([3,7],31)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([3,7],31)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (not (and |dn([3,7],31)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([3,7],31)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([3,7],31)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (= |dn([3,7],22)| (or |dn([7,Main.main],42)_dn([3,7],22)| |scc(2)_dn([3,7],22)| |scc(3)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (= |dn([7,Main.main],53)| (or |dn([9,Main.main],87)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (= |dn([6,9],93)| (or |scc(1)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (= |dn([7,Main.main],57)| (or |scc(1)_dn([7,Main.main],57)|))) -(assert (= |dn([Main.main],108)| (or |scc(8)_dn([Main.main],108)|))) -(assert (= |dn([7,Main.main],55)| (or |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (= |scc(1)| (or |dn([6,9],95)_scc(1)| |scc(7)_scc(1)| |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (= |dn([Main.main],105)| (or |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (= |scc(2)| (or |dn([5,1],62)_scc(2)|))) -(assert (= |dn([8,Main.main],97)| (or |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (= |dn([Main.main],103)| (or |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (= |scc(5)| (or |dn([3,7],30)_scc(5)|))) -(assert (= |dn([4,1],70)| (or |scc(4)_dn([4,1],70)|))) -(assert (= |dn([6,9],94)| (or |dn([6,9],93)_dn([6,9],94)|))) -(assert (= |dn([8,Main.main],100)| (or |scc(5)_dn([8,Main.main],100)|))) -(assert (= |dn([7,Main.main],59)| (or |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (= |dn([5,1],61)| (or |dn([1,3],67)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (= |dn([4,1],69)| (or |dn([1,3],65)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (= |dn([3,7],29)| (or |scc(6)_dn([3,7],29)| |scc(2)_dn([3,7],29)| |scc(3)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (= |dn([3,7],31)| (or |dn([2,3],36)_dn([3,7],31)| |scc(2)_dn([3,7],31)| |scc(3)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (= |dn([4,1],79)| (or |dn([4,1],78)_dn([4,1],79)|))) -(assert (= |dn([2,3],34)| (or |scc(0)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],34)| |scc(0)_dn([2,3],34)|))) -(assert (= |dn([Main.main],115)| (or |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (= |dn([2,3],37)| (or |dn([2,3],36)_dn([2,3],37)|))) -(assert (= |dn([1,3],68)| (or |dn([1,3],67)_dn([1,3],68)|))) -(assert (= |dn([4,1],81)| (or |dn([4,1],80)_dn([4,1],81)|))) -(assert (= |scc(7)| (or |dn([9,Main.main],87)_scc(7)| |scc(1)_scc(7)| |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (= |dn([9,Main.main],89)| (or |dn([9,Main.main],88)_dn([9,Main.main],89)|))) -(assert (= |dn([1,3],66)| (or |dn([1,3],65)_dn([1,3],66)|))) -(assert (= |dn([9,Main.main],84)| (or |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],65)| (or |dn([3,7],22)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (= |dn([7,Main.main],43)| (or |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (= |dn([9,Main.main],82)| (or |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (= |dn([7,Main.main],45)| (or |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (= |dn([3,7],30)| (or |dn([3,7],29)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not |scc(8)|)) -(assert (= |dn([9,Main.main],87)| (or |dn([9,Main.main],86)_dn([9,Main.main],87)|))) -(assert (= |dn([3,7],21)| (or |dn([3,7],20)_dn([3,7],21)|))) -(assert (= |dn([7,Main.main],49)| (or |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (= |scc(6)| (or |dn([3,7],28)_scc(6)|))) -(assert-soft |dn([7,Main.main],41)_dn([3,7],20)| :weight 1) -(assert-soft |scc(2)_dn([3,7],20)| :weight 1) -(assert-soft |scc(3)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],20)_dn([3,7],21)| :weight 1) -(assert-soft |dn([7,Main.main],42)_dn([3,7],22)| :weight 1) -(assert-soft |scc(2)_dn([3,7],22)| :weight 1) -(assert-soft |scc(3)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],22)| :weight 1) -(assert-soft |scc(0)_dn([3,7],24)| :weight 1) -(assert-soft |dn([3,7],24)_dn([3,7],25)| :weight 1) -(assert-soft |dn([8,Main.main],97)_dn([3,7],27)| :weight 2) -(assert-soft |scc(2)_dn([3,7],27)| :weight 2) -(assert-soft |scc(3)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],21)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],28)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],30)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],33)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],29)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],27)_dn([3,7],28)| :weight 6) -(assert-soft |dn([3,7],29)_dn([3,7],28)| :weight 6) -(assert-soft |scc(6)_dn([3,7],29)| :weight 2) -(assert-soft |scc(2)_dn([3,7],29)| :weight 2) -(assert-soft |scc(3)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],21)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],28)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],30)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],33)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],27)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],29)_dn([3,7],30)| :weight 6) -(assert-soft |dn([3,7],27)_dn([3,7],30)| :weight 6) -(assert-soft |dn([2,3],36)_dn([3,7],31)| :weight 1) -(assert-soft |scc(2)_dn([3,7],31)| :weight 1) -(assert-soft |scc(3)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],31)| :weight 1) -(assert-soft |dn([2,3],35)_dn([3,7],33)| :weight 1) -(assert-soft |scc(2)_dn([3,7],33)| :weight 1) -(assert-soft |scc(3)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],33)| :weight 1) -(assert-soft |scc(0)_dn([2,3],34)| :weight 1) -(assert-soft |dn([2,3],38)_dn([2,3],34)| :weight 1) -(assert-soft |scc(4)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],34)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],38)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],35)_dn([2,3],36)| :weight 1) -(assert-soft |dn([2,3],36)_dn([2,3],37)| :weight 1) -(assert-soft |dn([2,3],37)_dn([2,3],38)| :weight 1) -(assert-soft |dn([Main.main],103)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],39)| :weight 6) -(assert-soft |scc(1)_dn([7,Main.main],39)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],43)_dn([7,Main.main],40)| :weight 4) -(assert-soft |dn([7,Main.main],45)_dn([7,Main.main],40)| :weight 4) -(assert-soft |dn([7,Main.main],47)_dn([7,Main.main],41)| :weight 1) -(assert-soft |dn([7,Main.main],41)_dn([7,Main.main],42)| :weight 1) -(assert-soft |dn([7,Main.main],42)_dn([7,Main.main],43)| :weight 1) -(assert-soft |dn([7,Main.main],47)_dn([7,Main.main],45)| :weight 4) -(assert-soft |dn([Main.main],106)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],47)| :weight 8) -(assert-soft |scc(1)_dn([7,Main.main],47)| :weight 8) -(assert-soft |scc(7)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([Main.main],104)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],49)| :weight 8) -(assert-soft |scc(1)_dn([7,Main.main],49)| :weight 8) -(assert-soft |scc(7)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([Main.main],105)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],50)| :weight 2) -(assert-soft |scc(1)_dn([7,Main.main],50)| :weight 2) -(assert-soft |scc(7)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],51)| :weight 6) -(assert-soft |scc(1)_dn([7,Main.main],51)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([9,Main.main],87)_dn([7,Main.main],53)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],53)| :weight 6) -(assert-soft |dn([6,9],91)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],54)| :weight 2) -(assert-soft |scc(1)_dn([7,Main.main],54)| :weight 2) -(assert-soft |scc(7)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(1)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(7)_dn([7,Main.main],55)| :weight 18) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],55)| :weight 18) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(1)_dn([7,Main.main],57)| :weight 4) -(assert-soft |dn([2,3],37)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],58)| :weight 1) -(assert-soft |scc(1)_dn([7,Main.main],58)| :weight 1) -(assert-soft |scc(7)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],59)| :weight 1) -(assert-soft |scc(1)_dn([7,Main.main],59)| :weight 1) -(assert-soft |scc(7)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],59)_dn([7,Main.main],60)| :weight 1) -(assert-soft |dn([1,3],67)_dn([5,1],61)| :weight 1) -(assert-soft |dn([5,1],62)_dn([5,1],61)| :weight 1) -(assert-soft |dn([5,1],63)_dn([5,1],61)| :weight 1) -(assert-soft |dn([3,7],31)_dn([5,1],62)| :weight 1) -(assert-soft |dn([5,1],61)_dn([5,1],62)| :weight 1) -(assert-soft |dn([5,1],63)_dn([5,1],62)| :weight 1) -(assert-soft |scc(5)_dn([5,1],63)| :weight 8) -(assert-soft |dn([5,1],61)_dn([5,1],63)| :weight 8) -(assert-soft |dn([5,1],62)_dn([5,1],63)| :weight 8) -(assert-soft |dn([3,7],20)_dn([1,3],64)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],64)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],64)| :weight 1) -(assert-soft |dn([3,7],22)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],64)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],65)_dn([1,3],66)| :weight 1) -(assert-soft |dn([3,7],25)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],64)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],67)_dn([1,3],68)| :weight 1) -(assert-soft |dn([1,3],65)_dn([4,1],69)| :weight 1) -(assert-soft |dn([4,1],79)_dn([4,1],69)| :weight 1) -(assert-soft |dn([4,1],81)_dn([4,1],69)| :weight 1) -(assert-soft |scc(4)_dn([4,1],70)| :weight 2) -(assert-soft |dn([8,Main.main],100)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],69)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],79)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],81)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],78)_dn([4,1],79)| :weight 4) -(assert-soft |dn([3,7],24)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],69)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],79)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],81)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],80)_dn([4,1],81)| :weight 1) -(assert-soft |dn([Main.main],113)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([Main.main],114)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([7,Main.main],51)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],85)| :weight 6) -(assert-soft |dn([9,Main.main],85)_dn([9,Main.main],86)| :weight 6) -(assert-soft |dn([9,Main.main],86)_dn([9,Main.main],87)| :weight 2) -(assert-soft |dn([6,9],93)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],88)_dn([9,Main.main],89)| :weight 6) -(assert-soft |dn([9,Main.main],85)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],92)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],94)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],95)_dn([6,9],90)| :weight 8) -(assert-soft |dn([9,Main.main],86)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],90)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],92)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],94)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],95)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],91)_dn([6,9],92)| :weight 4) -(assert-soft |scc(1)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],90)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],92)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],94)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],95)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],93)_dn([6,9],94)| :weight 4) -(assert-soft |dn([7,Main.main],55)_dn([6,9],95)| :weight 6) -(assert-soft |dn([7,Main.main],59)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],90)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],92)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],94)_dn([6,9],95)| :weight 6) -(assert-soft |scc(8)_dn([8,Main.main],96)| :weight 4) -(assert-soft |dn([8,Main.main],101)_dn([8,Main.main],96)| :weight 4) -(assert-soft |dn([Main.main],108)_dn([8,Main.main],97)| :weight 8) -(assert-soft |dn([8,Main.main],96)_dn([8,Main.main],97)| :weight 8) -(assert-soft |dn([8,Main.main],101)_dn([8,Main.main],97)| :weight 8) -(assert-soft |scc(5)_dn([8,Main.main],100)| :weight 4) -(assert-soft |dn([8,Main.main],100)_dn([8,Main.main],101)| :weight 4) -(assert-soft |dn([Main.main],111)_dn([Main.main],102)| :weight 1) -(assert-soft |dn([Main.main],111)_dn([Main.main],103)| :weight 6) -(assert-soft |dn([Main.main],103)_dn([Main.main],104)| :weight 2) -(assert-soft |dn([Main.main],104)_dn([Main.main],105)| :weight 2) -(assert-soft |dn([Main.main],105)_dn([Main.main],106)| :weight 2) -(assert-soft |scc(8)_dn([Main.main],108)| :weight 2) -(assert-soft |dn([Main.main],108)_dn([Main.main],109)| :weight 6) -(assert-soft |dn([Main.main],109)_dn([Main.main],111)| :weight 6) -(assert-soft |dn([Main.main],115)_dn([Main.main],111)| :weight 6) -(assert-soft |dn([Main.main],116)_dn([Main.main],113)| :weight 3) -(assert-soft |dn([Main.main],113)_dn([Main.main],114)| :weight 1) -(assert-soft |dn([Main.main],114)_dn([Main.main],115)| :weight 1) -(assert-soft |dn([Main.main],115)_dn([Main.main],116)| :weight 2) -(assert-soft |dn([1,3],66)_scc(0)| :weight 1) -(assert-soft |dn([6,9],95)_scc(1)| :weight 6) -(assert-soft |scc(7)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],50)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],54)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],58)_scc(1)| :weight 6) -(assert-soft |dn([5,1],62)_scc(2)| :weight 1) -(assert-soft |dn([4,1],78)_scc(4)| :weight 4) -(assert-soft |dn([3,7],30)_scc(5)| :weight 8) -(assert-soft |dn([3,7],28)_scc(6)| :weight 6) -(assert-soft |dn([9,Main.main],87)_scc(7)| :weight 2) -(assert-soft |scc(1)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],50)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],54)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],58)_scc(7)| :weight 2) -(set-option :smt.pb.conflict_frequency 100) - -(optimize -; :wmaxsat_engine wpm2 - :wmaxsat_engine pwmax -; :wmaxsat_engine bvmax - :print_statistics true - :timeout 1200000 -) diff --git a/tests/chat_sls.smt2 b/tests/chat_sls.smt2 deleted file mode 100644 index 33a6d9b5e92..00000000000 --- a/tests/chat_sls.smt2 +++ /dev/null @@ -1,3380 +0,0 @@ -(declare-const |dn([7,Main.main],41)| Bool) -(declare-const |dn([3,7],24)| Bool) -(declare-const |dn([7,Main.main],47)| Bool) -(declare-const |dn([9,Main.main],86)| Bool) -(declare-const |dn([7,Main.main],51)| Bool) -(declare-const |dn([3,7],20)| Bool) -(declare-const |dn([6,9],91)| Bool) -(declare-const |scc(3)| Bool) -(declare-const |dn([6,9],92)| Bool) -(declare-const |scc(4)| Bool) -(declare-const |dn([7,Main.main],54)| Bool) -(declare-const |scc(0)| Bool) -(declare-const |dn([Main.main],109)| Bool) -(declare-const |dn([7,Main.main],58)| Bool) -(declare-const |dn([Main.main],104)| Bool) -(declare-const |dn([Main.main],102)| Bool) -(declare-const |dn([8,Main.main],101)| Bool) -(declare-const |dn([6,9],95)| Bool) -(declare-const |dn([8,Main.main],96)| Bool) -(declare-const |dn([3,7],28)| Bool) -(declare-const |dn([Main.main],106)| Bool) -(declare-const |dn([2,3],36)| Bool) -(declare-const |dn([4,1],78)| Bool) -(declare-const |dn([Main.main],114)| Bool) -(declare-const |dn([2,3],35)| Bool) -(declare-const |dn([2,3],38)| Bool) -(declare-const |dn([5,1],63)| Bool) -(declare-const |dn([7,Main.main],39)| Bool) -(declare-const |dn([3,7],33)| Bool) -(declare-const |dn([9,Main.main],88)| Bool) -(declare-const |dn([4,1],80)| Bool) -(declare-const |dn([Main.main],116)| Bool) -(declare-const |dn([Main.main],111)| Bool) -(declare-const |dn([7,Main.main],42)| Bool) -(declare-const |dn([9,Main.main],85)| Bool) -(declare-const |dn([3,7],27)| Bool) -(declare-const |dn([1,3],64)| Bool) -(declare-const |dn([9,Main.main],83)| Bool) -(declare-const |dn([1,3],67)| Bool) -(declare-const |dn([7,Main.main],40)| Bool) -(declare-const |dn([3,7],25)| Bool) -(declare-const |dn([6,9],90)| Bool) -(declare-const |dn([7,Main.main],60)| Bool) -(declare-const |dn([7,Main.main],50)| Bool) -(declare-const |dn([5,1],62)| Bool) -(declare-const |dn([3,7],22)| Bool) -(declare-const |dn([7,Main.main],53)| Bool) -(declare-const |dn([6,9],93)| Bool) -(declare-const |dn([7,Main.main],57)| Bool) -(declare-const |dn([Main.main],108)| Bool) -(declare-const |dn([7,Main.main],55)| Bool) -(declare-const |scc(1)| Bool) -(declare-const |dn([Main.main],105)| Bool) -(declare-const |scc(2)| Bool) -(declare-const |dn([8,Main.main],97)| Bool) -(declare-const |dn([Main.main],103)| Bool) -(declare-const |scc(5)| Bool) -(declare-const |dn([4,1],70)| Bool) -(declare-const |dn([6,9],94)| Bool) -(declare-const |dn([8,Main.main],100)| Bool) -(declare-const |dn([7,Main.main],59)| Bool) -(declare-const |dn([5,1],61)| Bool) -(declare-const |dn([4,1],69)| Bool) -(declare-const |dn([3,7],29)| Bool) -(declare-const |dn([3,7],31)| Bool) -(declare-const |dn([Main.main],113)| Bool) -(declare-const |dn([4,1],79)| Bool) -(declare-const |dn([2,3],34)| Bool) -(declare-const |dn([Main.main],115)| Bool) -(declare-const |dn([2,3],37)| Bool) -(declare-const |dn([1,3],68)| Bool) -(declare-const |dn([4,1],81)| Bool) -(declare-const |scc(7)| Bool) -(declare-const |dn([9,Main.main],89)| Bool) -(declare-const |dn([1,3],66)| Bool) -(declare-const |dn([9,Main.main],84)| Bool) -(declare-const |dn([1,3],65)| Bool) -(declare-const |dn([7,Main.main],43)| Bool) -(declare-const |dn([9,Main.main],82)| Bool) -(declare-const |dn([7,Main.main],45)| Bool) -(declare-const |dn([3,7],30)| Bool) -(declare-const |scc(8)| Bool) -(declare-const |dn([9,Main.main],87)| Bool) -(declare-const |dn([3,7],21)| Bool) -(declare-const |dn([7,Main.main],49)| Bool) -(declare-const |scc(6)| Bool) -(declare-const |dn([7,Main.main],41)_dn([3,7],20)| Bool) -(declare-const |dn([7,Main.main],41)_dn([7,Main.main],42)| Bool) -(declare-const |dn([3,7],24)_dn([3,7],25)| Bool) -(declare-const |dn([3,7],24)_dn([4,1],80)| Bool) -(declare-const |dn([7,Main.main],47)_dn([7,Main.main],41)| Bool) -(declare-const |dn([7,Main.main],47)_dn([7,Main.main],45)| Bool) -(declare-const |dn([9,Main.main],86)_dn([9,Main.main],87)| Bool) -(declare-const |dn([9,Main.main],86)_dn([6,9],91)| Bool) -(declare-const |dn([7,Main.main],51)_dn([9,Main.main],84)| Bool) -(declare-const |dn([3,7],20)_dn([3,7],21)| Bool) -(declare-const |dn([3,7],20)_dn([1,3],64)| Bool) -(declare-const |dn([6,9],91)_dn([7,Main.main],54)| Bool) -(declare-const |dn([6,9],91)_dn([6,9],92)| Bool) -(declare-const |scc(3)_dn([3,7],20)| Bool) -(declare-const |scc(3)_dn([3,7],22)| Bool) -(declare-const |scc(3)_dn([3,7],27)| Bool) -(declare-const |scc(3)_dn([3,7],29)| Bool) -(declare-const |scc(3)_dn([3,7],31)| Bool) -(declare-const |scc(3)_dn([3,7],33)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],92)_dn([6,9],95)| Bool) -(declare-const |scc(4)_dn([2,3],35)| Bool) -(declare-const |scc(4)_dn([4,1],70)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],54)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],54)_scc(1)| Bool) -(declare-const |dn([7,Main.main],54)_scc(7)| Bool) -(declare-const |scc(0)_dn([3,7],24)| Bool) -(declare-const |scc(0)_dn([2,3],34)| Bool) -(declare-const |dn([Main.main],109)_dn([Main.main],111)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],58)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],58)_scc(1)| Bool) -(declare-const |dn([7,Main.main],58)_scc(7)| Bool) -(declare-const |dn([Main.main],104)_dn([7,Main.main],49)| Bool) -(declare-const |dn([Main.main],104)_dn([Main.main],105)| Bool) -(declare-const |dn([8,Main.main],101)_dn([8,Main.main],96)| Bool) -(declare-const |dn([8,Main.main],101)_dn([8,Main.main],97)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],95)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],95)_scc(1)| Bool) -(declare-const |dn([8,Main.main],96)_dn([8,Main.main],97)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],28)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],28)_scc(6)| Bool) -(declare-const |dn([Main.main],106)_dn([7,Main.main],47)| Bool) -(declare-const |dn([2,3],36)_dn([3,7],31)| Bool) -(declare-const |dn([2,3],36)_dn([2,3],37)| Bool) -(declare-const |dn([4,1],78)_dn([4,1],79)| Bool) -(declare-const |dn([4,1],78)_scc(4)| Bool) -(declare-const |dn([Main.main],114)_dn([9,Main.main],83)| Bool) -(declare-const |dn([Main.main],114)_dn([Main.main],115)| Bool) -(declare-const |dn([2,3],35)_dn([3,7],33)| Bool) -(declare-const |dn([2,3],35)_dn([2,3],36)| Bool) -(declare-const |dn([2,3],38)_dn([2,3],34)| Bool) -(declare-const |dn([2,3],38)_dn([2,3],35)| Bool) -(declare-const |dn([5,1],63)_dn([5,1],61)| Bool) -(declare-const |dn([5,1],63)_dn([5,1],62)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],39)_dn([7,Main.main],58)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],33)_dn([3,7],31)| Bool) -(declare-const |dn([9,Main.main],88)_dn([9,Main.main],89)| Bool) -(declare-const |dn([4,1],80)_dn([4,1],81)| Bool) -(declare-const |dn([Main.main],116)_dn([Main.main],113)| Bool) -(declare-const |dn([Main.main],111)_dn([Main.main],102)| Bool) -(declare-const |dn([Main.main],111)_dn([Main.main],103)| Bool) -(declare-const |dn([7,Main.main],42)_dn([3,7],22)| Bool) -(declare-const |dn([7,Main.main],42)_dn([7,Main.main],43)| Bool) -(declare-const |dn([9,Main.main],85)_dn([9,Main.main],86)| Bool) -(declare-const |dn([9,Main.main],85)_dn([6,9],90)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],28)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],30)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],27)_dn([3,7],33)| Bool) -(declare-const |dn([1,3],64)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],64)_dn([1,3],67)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],83)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],67)_dn([5,1],61)| Bool) -(declare-const |dn([1,3],67)_dn([1,3],68)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],40)_dn([7,Main.main],58)| Bool) -(declare-const |dn([3,7],25)_dn([1,3],67)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],90)_dn([6,9],95)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],60)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],51)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],55)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],58)| Bool) -(declare-const |dn([7,Main.main],50)_dn([7,Main.main],59)| Bool) -(declare-const |dn([7,Main.main],50)_scc(1)| Bool) -(declare-const |dn([7,Main.main],50)_scc(7)| Bool) -(declare-const |dn([5,1],62)_dn([5,1],61)| Bool) -(declare-const |dn([5,1],62)_dn([5,1],63)| Bool) -(declare-const |dn([5,1],62)_scc(2)| Bool) -(declare-const |dn([3,7],22)_dn([1,3],65)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],53)_dn([7,Main.main],58)| Bool) -(declare-const |dn([6,9],93)_dn([9,Main.main],88)| Bool) -(declare-const |dn([6,9],93)_dn([6,9],94)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],49)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],57)_dn([7,Main.main],58)| Bool) -(declare-const |dn([Main.main],108)_dn([8,Main.main],97)| Bool) -(declare-const |dn([Main.main],108)_dn([Main.main],109)| Bool) -(declare-const |dn([7,Main.main],55)_dn([6,9],95)| Bool) -(declare-const |scc(1)_dn([7,Main.main],39)| Bool) -(declare-const |scc(1)_dn([7,Main.main],47)| Bool) -(declare-const |scc(1)_dn([7,Main.main],49)| Bool) -(declare-const |scc(1)_dn([7,Main.main],50)| Bool) -(declare-const |scc(1)_dn([7,Main.main],51)| Bool) -(declare-const |scc(1)_dn([7,Main.main],54)| Bool) -(declare-const |scc(1)_dn([7,Main.main],55)| Bool) -(declare-const |scc(1)_dn([7,Main.main],57)| Bool) -(declare-const |scc(1)_dn([7,Main.main],58)| Bool) -(declare-const |scc(1)_dn([7,Main.main],59)| Bool) -(declare-const |scc(1)_dn([6,9],93)| Bool) -(declare-const |scc(1)_scc(7)| Bool) -(declare-const |dn([Main.main],105)_dn([7,Main.main],50)| Bool) -(declare-const |dn([Main.main],105)_dn([Main.main],106)| Bool) -(declare-const |scc(2)_dn([3,7],20)| Bool) -(declare-const |scc(2)_dn([3,7],22)| Bool) -(declare-const |scc(2)_dn([3,7],27)| Bool) -(declare-const |scc(2)_dn([3,7],29)| Bool) -(declare-const |scc(2)_dn([3,7],31)| Bool) -(declare-const |scc(2)_dn([3,7],33)| Bool) -(declare-const |dn([8,Main.main],97)_dn([3,7],27)| Bool) -(declare-const |dn([Main.main],103)_dn([7,Main.main],39)| Bool) -(declare-const |dn([Main.main],103)_dn([Main.main],104)| Bool) -(declare-const |scc(5)_dn([5,1],63)| Bool) -(declare-const |scc(5)_dn([8,Main.main],100)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],90)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],91)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],93)| Bool) -(declare-const |dn([6,9],94)_dn([6,9],95)| Bool) -(declare-const |dn([8,Main.main],100)_dn([4,1],78)| Bool) -(declare-const |dn([8,Main.main],100)_dn([8,Main.main],101)| Bool) -(declare-const |dn([7,Main.main],59)_dn([7,Main.main],60)| Bool) -(declare-const |dn([7,Main.main],59)_dn([6,9],95)| Bool) -(declare-const |dn([5,1],61)_dn([5,1],62)| Bool) -(declare-const |dn([5,1],61)_dn([5,1],63)| Bool) -(declare-const |dn([4,1],69)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],69)_dn([4,1],80)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],28)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],30)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],29)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],31)_dn([5,1],62)| Bool) -(declare-const |dn([Main.main],113)_dn([9,Main.main],82)| Bool) -(declare-const |dn([Main.main],113)_dn([Main.main],114)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],69)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],79)_dn([4,1],80)| Bool) -(declare-const |dn([2,3],34)_dn([2,3],35)| Bool) -(declare-const |dn([Main.main],115)_dn([Main.main],111)| Bool) -(declare-const |dn([Main.main],115)_dn([Main.main],116)| Bool) -(declare-const |dn([2,3],37)_dn([2,3],38)| Bool) -(declare-const |dn([2,3],37)_dn([7,Main.main],58)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],64)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],68)_dn([1,3],67)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],69)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],78)| Bool) -(declare-const |dn([4,1],81)_dn([4,1],80)| Bool) -(declare-const |scc(7)_dn([7,Main.main],39)| Bool) -(declare-const |scc(7)_dn([7,Main.main],47)| Bool) -(declare-const |scc(7)_dn([7,Main.main],49)| Bool) -(declare-const |scc(7)_dn([7,Main.main],50)| Bool) -(declare-const |scc(7)_dn([7,Main.main],51)| Bool) -(declare-const |scc(7)_dn([7,Main.main],53)| Bool) -(declare-const |scc(7)_dn([7,Main.main],54)| Bool) -(declare-const |scc(7)_dn([7,Main.main],55)| Bool) -(declare-const |scc(7)_dn([7,Main.main],58)| Bool) -(declare-const |scc(7)_dn([7,Main.main],59)| Bool) -(declare-const |scc(7)_scc(1)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],89)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],64)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],65)| Bool) -(declare-const |dn([1,3],66)_dn([1,3],67)| Bool) -(declare-const |dn([1,3],66)_scc(0)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],85)| Bool) -(declare-const |dn([9,Main.main],84)_dn([9,Main.main],88)| Bool) -(declare-const |dn([1,3],65)_dn([1,3],66)| Bool) -(declare-const |dn([1,3],65)_dn([4,1],69)| Bool) -(declare-const |dn([7,Main.main],43)_dn([7,Main.main],40)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],82)_dn([9,Main.main],88)| Bool) -(declare-const |dn([7,Main.main],45)_dn([7,Main.main],40)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],30)_dn([3,7],33)| Bool) -(declare-const |dn([3,7],30)_scc(5)| Bool) -(declare-const |scc(8)_dn([8,Main.main],96)| Bool) -(declare-const |scc(8)_dn([Main.main],108)| Bool) -(declare-const |dn([9,Main.main],87)_dn([7,Main.main],53)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],82)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],83)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],84)| Bool) -(declare-const |dn([9,Main.main],87)_dn([9,Main.main],88)| Bool) -(declare-const |dn([9,Main.main],87)_scc(7)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],20)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],22)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],27)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],29)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],31)| Bool) -(declare-const |dn([3,7],21)_dn([3,7],33)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],39)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],47)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],50)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],54)| Bool) -(declare-const |dn([7,Main.main],49)_dn([7,Main.main],58)| Bool) -(declare-const |scc(6)_dn([3,7],29)| Bool) -(assert |dn([Main.main],113)|) -(assert (= |dn([7,Main.main],41)| (or |dn([7,Main.main],41)_dn([3,7],20)| |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (not (and |dn([7,Main.main],41)_dn([7,Main.main],42)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (= |dn([3,7],24)| (or |dn([3,7],24)_dn([3,7],25)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([3,7],25)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([3,7],24)_dn([3,7],25)|))) -(assert (= |dn([7,Main.main],47)| (or |dn([7,Main.main],47)_dn([7,Main.main],41)| |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (not (and |dn([7,Main.main],47)_dn([7,Main.main],41)| |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (not (and |dn([7,Main.main],47)_dn([7,Main.main],45)| |dn([7,Main.main],47)_dn([7,Main.main],41)|))) -(assert (= |dn([9,Main.main],86)| (or |dn([9,Main.main],86)_dn([9,Main.main],87)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([9,Main.main],87)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([9,Main.main],86)_dn([9,Main.main],87)|))) -(assert (= |dn([7,Main.main],51)| (or |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (= |dn([3,7],20)| (or |dn([3,7],20)_dn([3,7],21)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([3,7],21)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([3,7],20)_dn([3,7],21)|))) -(assert (= |dn([6,9],91)| (or |dn([6,9],91)_dn([7,Main.main],54)| |dn([6,9],91)_dn([6,9],92)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([6,9],91)_dn([6,9],92)|))) -(assert (not (and |dn([6,9],91)_dn([6,9],92)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (= |scc(3)| (or |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(3)_dn([3,7],31)|))) -(assert (= |dn([6,9],92)| (or |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (= |scc(4)| (or |scc(4)_dn([2,3],35)| |scc(4)_dn([4,1],70)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |scc(4)_dn([4,1],70)|))) -(assert (not (and |scc(4)_dn([4,1],70)| |scc(4)_dn([2,3],35)|))) -(assert (= |dn([7,Main.main],54)| (or |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],54)_scc(1)|))) -(assert (= |scc(0)| (or |scc(0)_dn([3,7],24)| |scc(0)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([3,7],24)| |scc(0)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([2,3],34)| |scc(0)_dn([3,7],24)|))) -(assert (= |dn([Main.main],109)| (or |dn([Main.main],109)_dn([Main.main],111)|))) -(assert (= |dn([7,Main.main],58)| (or |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],58)_scc(1)|))) -(assert (= |dn([Main.main],104)| (or |dn([Main.main],104)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (not (and |dn([Main.main],104)_dn([Main.main],105)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not |dn([Main.main],102)|)) -(assert (= |dn([8,Main.main],101)| (or |dn([8,Main.main],101)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (= |dn([6,9],95)| (or |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (= |dn([8,Main.main],96)| (or |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (= |dn([3,7],28)| (or |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],28)_scc(6)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_scc(6)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (= |dn([Main.main],106)| (or |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (= |dn([2,3],36)| (or |dn([2,3],36)_dn([3,7],31)| |dn([2,3],36)_dn([2,3],37)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([2,3],36)_dn([2,3],37)|))) -(assert (not (and |dn([2,3],36)_dn([2,3],37)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (= |dn([4,1],78)| (or |dn([4,1],78)_dn([4,1],79)| |dn([4,1],78)_scc(4)|))) -(assert (not (and |dn([4,1],78)_dn([4,1],79)| |dn([4,1],78)_scc(4)|))) -(assert (not (and |dn([4,1],78)_scc(4)| |dn([4,1],78)_dn([4,1],79)|))) -(assert (= |dn([Main.main],114)| (or |dn([Main.main],114)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (not (and |dn([Main.main],114)_dn([Main.main],115)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (= |dn([2,3],35)| (or |dn([2,3],35)_dn([3,7],33)| |dn([2,3],35)_dn([2,3],36)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([2,3],35)_dn([2,3],36)|))) -(assert (not (and |dn([2,3],35)_dn([2,3],36)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (= |dn([2,3],38)| (or |dn([2,3],38)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (= |dn([5,1],63)| (or |dn([5,1],63)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (= |dn([7,Main.main],39)| (or |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (= |dn([3,7],33)| (or |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (= |dn([9,Main.main],88)| (or |dn([9,Main.main],88)_dn([9,Main.main],89)|))) -(assert (= |dn([4,1],80)| (or |dn([4,1],80)_dn([4,1],81)|))) -(assert (= |dn([Main.main],116)| (or |dn([Main.main],116)_dn([Main.main],113)|))) -(assert (= |dn([Main.main],111)| (or |dn([Main.main],111)_dn([Main.main],102)| |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (not (and |dn([Main.main],111)_dn([Main.main],102)| |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (not (and |dn([Main.main],111)_dn([Main.main],103)| |dn([Main.main],111)_dn([Main.main],102)|))) -(assert (= |dn([7,Main.main],42)| (or |dn([7,Main.main],42)_dn([3,7],22)| |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (not (and |dn([7,Main.main],42)_dn([7,Main.main],43)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (= |dn([9,Main.main],85)| (or |dn([9,Main.main],85)_dn([9,Main.main],86)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([9,Main.main],86)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([9,Main.main],85)_dn([9,Main.main],86)|))) -(assert (= |dn([3,7],27)| (or |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (= |dn([1,3],64)| (or |dn([1,3],64)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (= |dn([9,Main.main],83)| (or |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],67)| (or |dn([1,3],67)_dn([5,1],61)| |dn([1,3],67)_dn([1,3],68)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([1,3],67)_dn([1,3],68)|))) -(assert (not (and |dn([1,3],67)_dn([1,3],68)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (= |dn([7,Main.main],40)| (or |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (= |dn([3,7],25)| (or |dn([3,7],25)_dn([1,3],67)|))) -(assert (= |dn([6,9],90)| (or |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (= |dn([7,Main.main],60)| (or |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (= |dn([7,Main.main],50)| (or |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],50)_scc(1)|))) -(assert (= |dn([5,1],62)| (or |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],62)_scc(2)|))) -(assert (not (and |dn([5,1],62)_scc(2)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_scc(2)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (= |dn([3,7],22)| (or |dn([3,7],22)_dn([1,3],65)|))) -(assert (= |dn([7,Main.main],53)| (or |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (= |dn([6,9],93)| (or |dn([6,9],93)_dn([9,Main.main],88)| |dn([6,9],93)_dn([6,9],94)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([6,9],93)_dn([6,9],94)|))) -(assert (not (and |dn([6,9],93)_dn([6,9],94)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (= |dn([7,Main.main],57)| (or |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (= |dn([Main.main],108)| (or |dn([Main.main],108)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (not (and |dn([Main.main],108)_dn([Main.main],109)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (= |dn([7,Main.main],55)| (or |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (= |scc(1)| (or |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([6,9],93)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],57)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |scc(1)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],57)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_scc(7)| |scc(1)_dn([6,9],93)|))) -(assert (= |dn([Main.main],105)| (or |dn([Main.main],105)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (not (and |dn([Main.main],105)_dn([Main.main],106)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (= |scc(2)| (or |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(2)_dn([3,7],31)|))) -(assert (= |dn([8,Main.main],97)| (or |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (= |dn([Main.main],103)| (or |dn([Main.main],103)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (not (and |dn([Main.main],103)_dn([Main.main],104)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (= |scc(5)| (or |scc(5)_dn([5,1],63)| |scc(5)_dn([8,Main.main],100)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |scc(5)_dn([8,Main.main],100)|))) -(assert (not (and |scc(5)_dn([8,Main.main],100)| |scc(5)_dn([5,1],63)|))) -(assert (not |dn([4,1],70)|)) -(assert (= |dn([6,9],94)| (or |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (= |dn([8,Main.main],100)| (or |dn([8,Main.main],100)_dn([4,1],78)| |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (not (and |dn([8,Main.main],100)_dn([8,Main.main],101)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (= |dn([7,Main.main],59)| (or |dn([7,Main.main],59)_dn([7,Main.main],60)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([7,Main.main],60)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([7,Main.main],59)_dn([7,Main.main],60)|))) -(assert (= |dn([5,1],61)| (or |dn([5,1],61)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (= |dn([4,1],69)| (or |dn([4,1],69)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (= |dn([3,7],29)| (or |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (= |dn([3,7],31)| (or |dn([3,7],31)_dn([5,1],62)|))) -(assert (= |dn([Main.main],113)| (or |dn([Main.main],113)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (not (and |dn([Main.main],113)_dn([Main.main],114)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (= |dn([4,1],79)| (or |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (= |dn([2,3],34)| (or |dn([2,3],34)_dn([2,3],35)|))) -(assert (= |dn([Main.main],115)| (or |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],116)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (= |dn([2,3],37)| (or |dn([2,3],37)_dn([2,3],38)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([2,3],38)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([2,3],37)_dn([2,3],38)|))) -(assert (= |dn([1,3],68)| (or |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (= |dn([4,1],81)| (or |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (= |scc(7)| (or |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],59)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(7)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_scc(1)| |scc(7)_dn([7,Main.main],59)|))) -(assert (= |dn([9,Main.main],89)| (or |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],66)| (or |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],66)_scc(0)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_scc(0)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (= |dn([9,Main.main],84)| (or |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],85)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (= |dn([1,3],65)| (or |dn([1,3],65)_dn([1,3],66)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([1,3],66)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([1,3],65)_dn([1,3],66)|))) -(assert (= |dn([7,Main.main],43)| (or |dn([7,Main.main],43)_dn([7,Main.main],40)|))) -(assert (= |dn([9,Main.main],82)| (or |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (= |dn([7,Main.main],45)| (or |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (= |dn([3,7],30)| (or |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],30)_scc(5)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_scc(5)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (= |scc(8)| (or |scc(8)_dn([8,Main.main],96)| |scc(8)_dn([Main.main],108)|))) -(assert (not (and |scc(8)_dn([8,Main.main],96)| |scc(8)_dn([Main.main],108)|))) -(assert (not (and |scc(8)_dn([Main.main],108)| |scc(8)_dn([8,Main.main],96)|))) -(assert (= |dn([9,Main.main],87)| (or |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (= |dn([7,Main.main],49)| (or |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (= |scc(6)| (or |scc(6)_dn([3,7],29)|))) -(assert (= |dn([7,Main.main],41)| (or |dn([7,Main.main],47)_dn([7,Main.main],41)|))) -(assert (= |dn([3,7],24)| (or |scc(0)_dn([3,7],24)|))) -(assert (= |dn([7,Main.main],47)| (or |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([Main.main],106)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |scc(1)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |scc(7)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],47)| |dn([7,Main.main],58)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([Main.main],106)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],39)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],40)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],49)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],53)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],57)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],60)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |scc(1)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |scc(7)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],50)_dn([7,Main.main],47)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],47)| |dn([7,Main.main],54)_dn([7,Main.main],47)|))) -(assert (= |dn([9,Main.main],86)| (or |dn([9,Main.main],85)_dn([9,Main.main],86)|))) -(assert (= |dn([7,Main.main],51)| (or |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |scc(1)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (not (and |scc(7)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],51)| |dn([7,Main.main],58)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],50)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |scc(1)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |scc(7)_dn([7,Main.main],51)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],51)| |dn([7,Main.main],54)_dn([7,Main.main],51)|))) -(assert (= |dn([3,7],20)| (or |dn([7,Main.main],41)_dn([3,7],20)| |scc(2)_dn([3,7],20)| |scc(3)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([7,Main.main],41)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |scc(2)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |scc(3)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],20)| |dn([3,7],29)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([7,Main.main],41)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |scc(2)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |scc(3)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],21)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],28)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],30)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],33)_dn([3,7],20)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],20)| |dn([3,7],27)_dn([3,7],20)|))) -(assert (= |dn([6,9],91)| (or |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([9,Main.main],86)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],91)| |dn([6,9],95)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([9,Main.main],86)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],90)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],92)_dn([6,9],91)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],91)| |dn([6,9],94)_dn([6,9],91)|))) -(assert (not |scc(3)|)) -(assert (= |dn([6,9],92)| (or |dn([6,9],91)_dn([6,9],92)|))) -(assert (= |scc(4)| (or |dn([4,1],78)_scc(4)|))) -(assert (= |dn([7,Main.main],54)| (or |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([6,9],91)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |scc(1)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (not (and |scc(7)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],54)| |dn([7,Main.main],58)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([6,9],91)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],39)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],40)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],49)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],53)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],57)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],60)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |scc(1)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |scc(7)_dn([7,Main.main],54)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],54)| |dn([7,Main.main],50)_dn([7,Main.main],54)|))) -(assert (= |scc(0)| (or |dn([1,3],66)_scc(0)|))) -(assert (= |dn([Main.main],109)| (or |dn([Main.main],108)_dn([Main.main],109)|))) -(assert (= |dn([7,Main.main],58)| (or |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([2,3],37)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |scc(1)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (not (and |scc(7)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],58)| |dn([7,Main.main],54)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([2,3],37)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],39)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],40)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],49)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],53)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],57)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],60)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |scc(1)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |scc(7)_dn([7,Main.main],58)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],58)| |dn([7,Main.main],50)_dn([7,Main.main],58)|))) -(assert (= |dn([Main.main],104)| (or |dn([Main.main],103)_dn([Main.main],104)|))) -(assert (= |dn([Main.main],102)| (or |dn([Main.main],111)_dn([Main.main],102)|))) -(assert (= |dn([8,Main.main],101)| (or |dn([8,Main.main],100)_dn([8,Main.main],101)|))) -(assert (= |dn([6,9],95)| (or |dn([7,Main.main],55)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],55)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([7,Main.main],59)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],95)| |dn([6,9],94)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([7,Main.main],55)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([7,Main.main],59)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],90)_dn([6,9],95)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],95)| |dn([6,9],92)_dn([6,9],95)|))) -(assert (= |dn([8,Main.main],96)| (or |scc(8)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (not (and |scc(8)_dn([8,Main.main],96)| |dn([8,Main.main],101)_dn([8,Main.main],96)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],96)| |scc(8)_dn([8,Main.main],96)|))) -(assert (= |dn([3,7],28)| (or |dn([3,7],27)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],28)| |dn([3,7],29)_dn([3,7],28)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],28)| |dn([3,7],27)_dn([3,7],28)|))) -(assert (= |dn([Main.main],106)| (or |dn([Main.main],105)_dn([Main.main],106)|))) -(assert (= |dn([2,3],36)| (or |dn([2,3],35)_dn([2,3],36)|))) -(assert (= |dn([4,1],78)| (or |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([8,Main.main],100)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],78)| |dn([4,1],81)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([8,Main.main],100)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],69)_dn([4,1],78)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],78)| |dn([4,1],79)_dn([4,1],78)|))) -(assert (= |dn([Main.main],114)| (or |dn([Main.main],113)_dn([Main.main],114)|))) -(assert (= |dn([2,3],35)| (or |scc(4)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)|))) -(assert (not (and |scc(4)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],34)_dn([2,3],35)| |scc(4)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],34)_dn([2,3],35)| |dn([2,3],38)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |scc(4)_dn([2,3],35)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],35)| |dn([2,3],34)_dn([2,3],35)|))) -(assert (= |dn([2,3],38)| (or |dn([2,3],37)_dn([2,3],38)|))) -(assert (= |dn([5,1],63)| (or |scc(5)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (not (and |scc(5)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |scc(5)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],63)| |dn([5,1],62)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |scc(5)_dn([5,1],63)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],63)| |dn([5,1],61)_dn([5,1],63)|))) -(assert (= |dn([7,Main.main],39)| (or |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([Main.main],103)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |scc(1)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |scc(7)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],39)| |dn([7,Main.main],58)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([Main.main],103)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],40)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],49)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],53)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],57)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],60)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |scc(1)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |scc(7)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],50)_dn([7,Main.main],39)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],39)| |dn([7,Main.main],54)_dn([7,Main.main],39)|))) -(assert (= |dn([3,7],33)| (or |dn([2,3],35)_dn([3,7],33)| |scc(2)_dn([3,7],33)| |scc(3)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([2,3],35)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |scc(2)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |scc(3)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],33)| |dn([3,7],29)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([2,3],35)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |scc(2)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |scc(3)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],21)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],28)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],30)_dn([3,7],33)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],33)| |dn([3,7],27)_dn([3,7],33)|))) -(assert (= |dn([9,Main.main],88)| (or |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([6,9],93)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],88)| |dn([9,Main.main],84)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([6,9],93)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],82)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],83)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],87)_dn([9,Main.main],88)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],88)| |dn([9,Main.main],89)_dn([9,Main.main],88)|))) -(assert (= |dn([4,1],80)| (or |dn([3,7],24)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([3,7],24)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],69)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],80)| |dn([4,1],81)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([3,7],24)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],69)_dn([4,1],80)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],80)| |dn([4,1],79)_dn([4,1],80)|))) -(assert (= |dn([Main.main],116)| (or |dn([Main.main],115)_dn([Main.main],116)|))) -(assert (= |dn([Main.main],111)| (or |dn([Main.main],109)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (not (and |dn([Main.main],109)_dn([Main.main],111)| |dn([Main.main],115)_dn([Main.main],111)|))) -(assert (not (and |dn([Main.main],115)_dn([Main.main],111)| |dn([Main.main],109)_dn([Main.main],111)|))) -(assert (= |dn([7,Main.main],42)| (or |dn([7,Main.main],41)_dn([7,Main.main],42)|))) -(assert (= |dn([9,Main.main],85)| (or |dn([9,Main.main],84)_dn([9,Main.main],85)|))) -(assert (= |dn([3,7],27)| (or |dn([8,Main.main],97)_dn([3,7],27)| |scc(2)_dn([3,7],27)| |scc(3)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([8,Main.main],97)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |scc(2)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |scc(3)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],27)| |dn([3,7],29)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([8,Main.main],97)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |scc(2)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |scc(3)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],21)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],28)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],30)_dn([3,7],27)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],27)| |dn([3,7],33)_dn([3,7],27)|))) -(assert (= |dn([1,3],64)| (or |dn([3,7],20)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (not (and |dn([3,7],20)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],64)| |dn([1,3],68)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([3,7],20)_dn([1,3],64)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],64)| |dn([1,3],66)_dn([1,3],64)|))) -(assert (= |dn([9,Main.main],83)| (or |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([Main.main],114)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],83)| |dn([9,Main.main],84)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([Main.main],114)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],82)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],87)_dn([9,Main.main],83)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],83)| |dn([9,Main.main],89)_dn([9,Main.main],83)|))) -(assert (= |dn([1,3],67)| (or |dn([3,7],25)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([3,7],25)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],67)| |dn([1,3],68)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([3,7],25)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],64)_dn([1,3],67)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],67)| |dn([1,3],66)_dn([1,3],67)|))) -(assert (= |dn([7,Main.main],40)| (or |dn([7,Main.main],43)_dn([7,Main.main],40)| |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (not (and |dn([7,Main.main],43)_dn([7,Main.main],40)| |dn([7,Main.main],45)_dn([7,Main.main],40)|))) -(assert (not (and |dn([7,Main.main],45)_dn([7,Main.main],40)| |dn([7,Main.main],43)_dn([7,Main.main],40)|))) -(assert (= |dn([3,7],25)| (or |dn([3,7],24)_dn([3,7],25)|))) -(assert (= |dn([6,9],90)| (or |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([9,Main.main],85)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],90)| |dn([6,9],95)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([9,Main.main],85)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],92)_dn([6,9],90)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],90)| |dn([6,9],94)_dn([6,9],90)|))) -(assert (= |dn([7,Main.main],60)| (or |dn([7,Main.main],59)_dn([7,Main.main],60)|))) -(assert (= |dn([7,Main.main],50)| (or |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([Main.main],105)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],49)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |scc(1)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (not (and |scc(7)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],50)| |dn([7,Main.main],58)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([Main.main],105)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],39)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],40)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],49)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],53)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],57)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],60)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |scc(1)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |scc(7)_dn([7,Main.main],50)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],50)| |dn([7,Main.main],54)_dn([7,Main.main],50)|))) -(assert (= |dn([5,1],62)| (or |dn([3,7],31)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([3,7],31)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (not (and |dn([3,7],31)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([3,7],31)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],61)_dn([5,1],62)| |dn([5,1],63)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([3,7],31)_dn([5,1],62)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],62)| |dn([5,1],61)_dn([5,1],62)|))) -(assert (= |dn([3,7],22)| (or |dn([7,Main.main],42)_dn([3,7],22)| |scc(2)_dn([3,7],22)| |scc(3)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([7,Main.main],42)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |scc(2)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |scc(3)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],22)| |dn([3,7],29)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([7,Main.main],42)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |scc(2)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |scc(3)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],21)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],28)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],30)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],33)_dn([3,7],22)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],22)| |dn([3,7],27)_dn([3,7],22)|))) -(assert (= |dn([7,Main.main],53)| (or |dn([9,Main.main],87)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |dn([9,Main.main],87)_dn([7,Main.main],53)| |scc(7)_dn([7,Main.main],53)|))) -(assert (not (and |scc(7)_dn([7,Main.main],53)| |dn([9,Main.main],87)_dn([7,Main.main],53)|))) -(assert (= |dn([6,9],93)| (or |scc(1)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |scc(1)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],90)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],92)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],94)_dn([6,9],93)| |dn([6,9],95)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |scc(1)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],90)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],92)_dn([6,9],93)|))) -(assert (not (and |dn([6,9],95)_dn([6,9],93)| |dn([6,9],94)_dn([6,9],93)|))) -(assert (= |dn([7,Main.main],57)| (or |scc(1)_dn([7,Main.main],57)|))) -(assert (= |dn([Main.main],108)| (or |scc(8)_dn([Main.main],108)|))) -(assert (= |dn([7,Main.main],55)| (or |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |scc(1)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (not (and |scc(7)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],55)| |dn([7,Main.main],58)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],54)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |scc(1)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |scc(7)_dn([7,Main.main],55)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],55)| |dn([7,Main.main],50)_dn([7,Main.main],55)|))) -(assert (= |scc(1)| (or |dn([6,9],95)_scc(1)| |scc(7)_scc(1)| |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([6,9],95)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |scc(7)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (not (and |dn([7,Main.main],50)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],54)_scc(1)| |dn([7,Main.main],58)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([6,9],95)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |scc(7)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],50)_scc(1)|))) -(assert (not (and |dn([7,Main.main],58)_scc(1)| |dn([7,Main.main],54)_scc(1)|))) -(assert (= |dn([Main.main],105)| (or |dn([Main.main],104)_dn([Main.main],105)|))) -(assert (= |scc(2)| (or |dn([5,1],62)_scc(2)|))) -(assert (= |dn([8,Main.main],97)| (or |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (not (and |dn([Main.main],108)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],96)_dn([8,Main.main],97)| |dn([8,Main.main],101)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([Main.main],108)_dn([8,Main.main],97)|))) -(assert (not (and |dn([8,Main.main],101)_dn([8,Main.main],97)| |dn([8,Main.main],96)_dn([8,Main.main],97)|))) -(assert (= |dn([Main.main],103)| (or |dn([Main.main],111)_dn([Main.main],103)|))) -(assert (= |scc(5)| (or |dn([3,7],30)_scc(5)|))) -(assert (= |dn([4,1],70)| (or |scc(4)_dn([4,1],70)|))) -(assert (= |dn([6,9],94)| (or |dn([6,9],93)_dn([6,9],94)|))) -(assert (= |dn([8,Main.main],100)| (or |scc(5)_dn([8,Main.main],100)|))) -(assert (= |dn([7,Main.main],59)| (or |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |scc(1)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (not (and |scc(7)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],59)| |dn([7,Main.main],54)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],58)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |scc(1)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |scc(7)_dn([7,Main.main],59)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],59)| |dn([7,Main.main],50)_dn([7,Main.main],59)|))) -(assert (= |dn([5,1],61)| (or |dn([1,3],67)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (not (and |dn([1,3],67)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],62)_dn([5,1],61)| |dn([5,1],63)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([1,3],67)_dn([5,1],61)|))) -(assert (not (and |dn([5,1],63)_dn([5,1],61)| |dn([5,1],62)_dn([5,1],61)|))) -(assert (= |dn([4,1],69)| (or |dn([1,3],65)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (not (and |dn([1,3],65)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],79)_dn([4,1],69)| |dn([4,1],81)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([1,3],65)_dn([4,1],69)|))) -(assert (not (and |dn([4,1],81)_dn([4,1],69)| |dn([4,1],79)_dn([4,1],69)|))) -(assert (= |dn([3,7],29)| (or |scc(6)_dn([3,7],29)| |scc(2)_dn([3,7],29)| |scc(3)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(6)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(2)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |scc(3)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],29)| |dn([3,7],27)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(6)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(2)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |scc(3)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],21)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],28)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],30)_dn([3,7],29)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],29)| |dn([3,7],33)_dn([3,7],29)|))) -(assert (= |dn([3,7],31)| (or |dn([2,3],36)_dn([3,7],31)| |scc(2)_dn([3,7],31)| |scc(3)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([2,3],36)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |scc(2)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |scc(3)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],21)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],28)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],30)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],33)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],31)| |dn([3,7],29)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([2,3],36)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |scc(2)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |scc(3)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],21)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],28)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],30)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],33)_dn([3,7],31)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],31)| |dn([3,7],27)_dn([3,7],31)|))) -(assert (= |dn([4,1],79)| (or |dn([4,1],78)_dn([4,1],79)|))) -(assert (= |dn([2,3],34)| (or |scc(0)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (not (and |scc(0)_dn([2,3],34)| |dn([2,3],38)_dn([2,3],34)|))) -(assert (not (and |dn([2,3],38)_dn([2,3],34)| |scc(0)_dn([2,3],34)|))) -(assert (= |dn([Main.main],115)| (or |dn([Main.main],114)_dn([Main.main],115)|))) -(assert (= |dn([2,3],37)| (or |dn([2,3],36)_dn([2,3],37)|))) -(assert (= |dn([1,3],68)| (or |dn([1,3],67)_dn([1,3],68)|))) -(assert (= |dn([4,1],81)| (or |dn([4,1],80)_dn([4,1],81)|))) -(assert (= |scc(7)| (or |dn([9,Main.main],87)_scc(7)| |scc(1)_scc(7)| |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([9,Main.main],87)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |scc(1)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (not (and |dn([7,Main.main],50)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],54)_scc(7)| |dn([7,Main.main],58)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([9,Main.main],87)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |scc(1)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],50)_scc(7)|))) -(assert (not (and |dn([7,Main.main],58)_scc(7)| |dn([7,Main.main],54)_scc(7)|))) -(assert (= |dn([9,Main.main],89)| (or |dn([9,Main.main],88)_dn([9,Main.main],89)|))) -(assert (= |dn([1,3],66)| (or |dn([1,3],65)_dn([1,3],66)|))) -(assert (= |dn([9,Main.main],84)| (or |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([7,Main.main],51)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],82)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],84)| |dn([9,Main.main],89)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([7,Main.main],51)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],82)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],83)_dn([9,Main.main],84)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],84)| |dn([9,Main.main],87)_dn([9,Main.main],84)|))) -(assert (= |dn([1,3],65)| (or |dn([3,7],22)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([3,7],22)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],64)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],66)_dn([1,3],65)| |dn([1,3],68)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([3,7],22)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],64)_dn([1,3],65)|))) -(assert (not (and |dn([1,3],68)_dn([1,3],65)| |dn([1,3],66)_dn([1,3],65)|))) -(assert (= |dn([7,Main.main],43)| (or |dn([7,Main.main],42)_dn([7,Main.main],43)|))) -(assert (= |dn([9,Main.main],82)| (or |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([Main.main],113)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],83)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],87)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],89)_dn([9,Main.main],82)| |dn([9,Main.main],84)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([Main.main],113)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],83)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],87)_dn([9,Main.main],82)|))) -(assert (not (and |dn([9,Main.main],84)_dn([9,Main.main],82)| |dn([9,Main.main],89)_dn([9,Main.main],82)|))) -(assert (= |dn([7,Main.main],45)| (or |dn([7,Main.main],47)_dn([7,Main.main],45)|))) -(assert (= |dn([3,7],30)| (or |dn([3,7],29)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],29)_dn([3,7],30)| |dn([3,7],27)_dn([3,7],30)|))) -(assert (not (and |dn([3,7],27)_dn([3,7],30)| |dn([3,7],29)_dn([3,7],30)|))) -(assert (not |scc(8)|)) -(assert (= |dn([9,Main.main],87)| (or |dn([9,Main.main],86)_dn([9,Main.main],87)|))) -(assert (= |dn([3,7],21)| (or |dn([3,7],20)_dn([3,7],21)|))) -(assert (= |dn([7,Main.main],49)| (or |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([Main.main],104)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],39)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],40)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],53)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],57)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],60)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |scc(1)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |scc(7)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],50)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],54)_dn([7,Main.main],49)| |dn([7,Main.main],58)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([Main.main],104)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],39)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],40)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],53)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],57)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],60)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |scc(1)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |scc(7)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],50)_dn([7,Main.main],49)|))) -(assert (not (and |dn([7,Main.main],58)_dn([7,Main.main],49)| |dn([7,Main.main],54)_dn([7,Main.main],49)|))) -(assert (= |scc(6)| (or |dn([3,7],28)_scc(6)|))) -(assert-soft |dn([7,Main.main],41)_dn([3,7],20)| :weight 1) -(assert-soft |scc(2)_dn([3,7],20)| :weight 1) -(assert-soft |scc(3)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],20)| :weight 1) -(assert-soft |dn([3,7],20)_dn([3,7],21)| :weight 1) -(assert-soft |dn([7,Main.main],42)_dn([3,7],22)| :weight 1) -(assert-soft |scc(2)_dn([3,7],22)| :weight 1) -(assert-soft |scc(3)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],22)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],22)| :weight 1) -(assert-soft |scc(0)_dn([3,7],24)| :weight 1) -(assert-soft |dn([3,7],24)_dn([3,7],25)| :weight 1) -(assert-soft |dn([8,Main.main],97)_dn([3,7],27)| :weight 2) -(assert-soft |scc(2)_dn([3,7],27)| :weight 2) -(assert-soft |scc(3)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],21)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],28)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],30)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],33)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],29)_dn([3,7],27)| :weight 2) -(assert-soft |dn([3,7],27)_dn([3,7],28)| :weight 6) -(assert-soft |dn([3,7],29)_dn([3,7],28)| :weight 6) -(assert-soft |scc(6)_dn([3,7],29)| :weight 2) -(assert-soft |scc(2)_dn([3,7],29)| :weight 2) -(assert-soft |scc(3)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],21)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],28)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],30)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],33)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],27)_dn([3,7],29)| :weight 2) -(assert-soft |dn([3,7],29)_dn([3,7],30)| :weight 6) -(assert-soft |dn([3,7],27)_dn([3,7],30)| :weight 6) -(assert-soft |dn([2,3],36)_dn([3,7],31)| :weight 1) -(assert-soft |scc(2)_dn([3,7],31)| :weight 1) -(assert-soft |scc(3)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],33)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],31)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],31)| :weight 1) -(assert-soft |dn([2,3],35)_dn([3,7],33)| :weight 1) -(assert-soft |scc(2)_dn([3,7],33)| :weight 1) -(assert-soft |scc(3)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],21)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],28)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],30)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],27)_dn([3,7],33)| :weight 1) -(assert-soft |dn([3,7],29)_dn([3,7],33)| :weight 1) -(assert-soft |scc(0)_dn([2,3],34)| :weight 1) -(assert-soft |dn([2,3],38)_dn([2,3],34)| :weight 1) -(assert-soft |scc(4)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],34)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],38)_dn([2,3],35)| :weight 1) -(assert-soft |dn([2,3],35)_dn([2,3],36)| :weight 1) -(assert-soft |dn([2,3],36)_dn([2,3],37)| :weight 1) -(assert-soft |dn([2,3],37)_dn([2,3],38)| :weight 1) -(assert-soft |dn([Main.main],103)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],39)| :weight 6) -(assert-soft |scc(1)_dn([7,Main.main],39)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],39)| :weight 6) -(assert-soft |dn([7,Main.main],43)_dn([7,Main.main],40)| :weight 4) -(assert-soft |dn([7,Main.main],45)_dn([7,Main.main],40)| :weight 4) -(assert-soft |dn([7,Main.main],47)_dn([7,Main.main],41)| :weight 1) -(assert-soft |dn([7,Main.main],41)_dn([7,Main.main],42)| :weight 1) -(assert-soft |dn([7,Main.main],42)_dn([7,Main.main],43)| :weight 1) -(assert-soft |dn([7,Main.main],47)_dn([7,Main.main],45)| :weight 4) -(assert-soft |dn([Main.main],106)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],47)| :weight 8) -(assert-soft |scc(1)_dn([7,Main.main],47)| :weight 8) -(assert-soft |scc(7)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],47)| :weight 8) -(assert-soft |dn([Main.main],104)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],49)| :weight 8) -(assert-soft |scc(1)_dn([7,Main.main],49)| :weight 8) -(assert-soft |scc(7)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],49)| :weight 8) -(assert-soft |dn([Main.main],105)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],50)| :weight 2) -(assert-soft |scc(1)_dn([7,Main.main],50)| :weight 2) -(assert-soft |scc(7)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],50)| :weight 2) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],51)| :weight 6) -(assert-soft |scc(1)_dn([7,Main.main],51)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],51)| :weight 6) -(assert-soft |dn([9,Main.main],87)_dn([7,Main.main],53)| :weight 6) -(assert-soft |scc(7)_dn([7,Main.main],53)| :weight 6) -(assert-soft |dn([6,9],91)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],54)| :weight 2) -(assert-soft |scc(1)_dn([7,Main.main],54)| :weight 2) -(assert-soft |scc(7)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],54)| :weight 2) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(1)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(7)_dn([7,Main.main],55)| :weight 18) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],55)| :weight 18) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],55)| :weight 18) -(assert-soft |scc(1)_dn([7,Main.main],57)| :weight 4) -(assert-soft |dn([2,3],37)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],39)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],40)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],49)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],53)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],57)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],60)_dn([7,Main.main],58)| :weight 1) -(assert-soft |scc(1)_dn([7,Main.main],58)| :weight 1) -(assert-soft |scc(7)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],58)| :weight 1) -(assert-soft |dn([7,Main.main],58)_dn([7,Main.main],59)| :weight 1) -(assert-soft |scc(1)_dn([7,Main.main],59)| :weight 1) -(assert-soft |scc(7)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],50)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],54)_dn([7,Main.main],59)| :weight 1) -(assert-soft |dn([7,Main.main],59)_dn([7,Main.main],60)| :weight 1) -(assert-soft |dn([1,3],67)_dn([5,1],61)| :weight 1) -(assert-soft |dn([5,1],62)_dn([5,1],61)| :weight 1) -(assert-soft |dn([5,1],63)_dn([5,1],61)| :weight 1) -(assert-soft |dn([3,7],31)_dn([5,1],62)| :weight 1) -(assert-soft |dn([5,1],61)_dn([5,1],62)| :weight 1) -(assert-soft |dn([5,1],63)_dn([5,1],62)| :weight 1) -(assert-soft |scc(5)_dn([5,1],63)| :weight 8) -(assert-soft |dn([5,1],61)_dn([5,1],63)| :weight 8) -(assert-soft |dn([5,1],62)_dn([5,1],63)| :weight 8) -(assert-soft |dn([3,7],20)_dn([1,3],64)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],64)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],64)| :weight 1) -(assert-soft |dn([3,7],22)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],64)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],65)| :weight 1) -(assert-soft |dn([1,3],65)_dn([1,3],66)| :weight 1) -(assert-soft |dn([3,7],25)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],64)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],66)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],68)_dn([1,3],67)| :weight 1) -(assert-soft |dn([1,3],67)_dn([1,3],68)| :weight 1) -(assert-soft |dn([1,3],65)_dn([4,1],69)| :weight 1) -(assert-soft |dn([4,1],79)_dn([4,1],69)| :weight 1) -(assert-soft |dn([4,1],81)_dn([4,1],69)| :weight 1) -(assert-soft |scc(4)_dn([4,1],70)| :weight 2) -(assert-soft |dn([8,Main.main],100)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],69)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],79)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],81)_dn([4,1],78)| :weight 6) -(assert-soft |dn([4,1],78)_dn([4,1],79)| :weight 4) -(assert-soft |dn([3,7],24)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],69)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],79)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],81)_dn([4,1],80)| :weight 1) -(assert-soft |dn([4,1],80)_dn([4,1],81)| :weight 1) -(assert-soft |dn([Main.main],113)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],82)| :weight 4) -(assert-soft |dn([Main.main],114)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],83)| :weight 4) -(assert-soft |dn([7,Main.main],51)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],84)| :weight 2) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],85)| :weight 6) -(assert-soft |dn([9,Main.main],85)_dn([9,Main.main],86)| :weight 6) -(assert-soft |dn([9,Main.main],86)_dn([9,Main.main],87)| :weight 2) -(assert-soft |dn([6,9],93)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],82)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],83)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],87)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],89)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],84)_dn([9,Main.main],88)| :weight 6) -(assert-soft |dn([9,Main.main],88)_dn([9,Main.main],89)| :weight 6) -(assert-soft |dn([9,Main.main],85)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],92)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],94)_dn([6,9],90)| :weight 8) -(assert-soft |dn([6,9],95)_dn([6,9],90)| :weight 8) -(assert-soft |dn([9,Main.main],86)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],90)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],92)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],94)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],95)_dn([6,9],91)| :weight 8) -(assert-soft |dn([6,9],91)_dn([6,9],92)| :weight 4) -(assert-soft |scc(1)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],90)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],92)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],94)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],95)_dn([6,9],93)| :weight 6) -(assert-soft |dn([6,9],93)_dn([6,9],94)| :weight 4) -(assert-soft |dn([7,Main.main],55)_dn([6,9],95)| :weight 6) -(assert-soft |dn([7,Main.main],59)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],90)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],92)_dn([6,9],95)| :weight 6) -(assert-soft |dn([6,9],94)_dn([6,9],95)| :weight 6) -(assert-soft |scc(8)_dn([8,Main.main],96)| :weight 4) -(assert-soft |dn([8,Main.main],101)_dn([8,Main.main],96)| :weight 4) -(assert-soft |dn([Main.main],108)_dn([8,Main.main],97)| :weight 8) -(assert-soft |dn([8,Main.main],96)_dn([8,Main.main],97)| :weight 8) -(assert-soft |dn([8,Main.main],101)_dn([8,Main.main],97)| :weight 8) -(assert-soft |scc(5)_dn([8,Main.main],100)| :weight 4) -(assert-soft |dn([8,Main.main],100)_dn([8,Main.main],101)| :weight 4) -(assert-soft |dn([Main.main],111)_dn([Main.main],102)| :weight 1) -(assert-soft |dn([Main.main],111)_dn([Main.main],103)| :weight 6) -(assert-soft |dn([Main.main],103)_dn([Main.main],104)| :weight 2) -(assert-soft |dn([Main.main],104)_dn([Main.main],105)| :weight 2) -(assert-soft |dn([Main.main],105)_dn([Main.main],106)| :weight 2) -(assert-soft |scc(8)_dn([Main.main],108)| :weight 2) -(assert-soft |dn([Main.main],108)_dn([Main.main],109)| :weight 6) -(assert-soft |dn([Main.main],109)_dn([Main.main],111)| :weight 6) -(assert-soft |dn([Main.main],115)_dn([Main.main],111)| :weight 6) -(assert-soft |dn([Main.main],116)_dn([Main.main],113)| :weight 3) -(assert-soft |dn([Main.main],113)_dn([Main.main],114)| :weight 1) -(assert-soft |dn([Main.main],114)_dn([Main.main],115)| :weight 1) -(assert-soft |dn([Main.main],115)_dn([Main.main],116)| :weight 2) -(assert-soft |dn([1,3],66)_scc(0)| :weight 1) -(assert-soft |dn([6,9],95)_scc(1)| :weight 6) -(assert-soft |scc(7)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],50)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],54)_scc(1)| :weight 6) -(assert-soft |dn([7,Main.main],58)_scc(1)| :weight 6) -(assert-soft |dn([5,1],62)_scc(2)| :weight 1) -(assert-soft |dn([4,1],78)_scc(4)| :weight 4) -(assert-soft |dn([3,7],30)_scc(5)| :weight 8) -(assert-soft |dn([3,7],28)_scc(6)| :weight 6) -(assert-soft |dn([9,Main.main],87)_scc(7)| :weight 2) -(assert-soft |scc(1)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],50)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],54)_scc(7)| :weight 2) -(assert-soft |dn([7,Main.main],58)_scc(7)| :weight 2) -(set-option :smt.pb.conflict_frequency 100) - -(optimize - :wmaxsat_engine bvsls - :print_statistics true - :timeout 1200000 -) diff --git a/tests/ravi_sls.smt2 b/tests/ravi_sls.smt2 deleted file mode 100644 index 7db65dc4097..00000000000 --- a/tests/ravi_sls.smt2 +++ /dev/null @@ -1,443 +0,0 @@ -(set-option :smt.relevancy 0) -(set-option :smt.pb.conflict_frequency 10000) -(set-option :opt.pb.compile_equality true) -(set-option :smt.pb.enable_simplex true) -; declare an integer variable for each mini-pathlet's multiplicity -(declare-const A0_2_3_10 Int) -(declare-const A0_2_3_5_4_7_9 Int) -(declare-const A0_2_3_5_4_8_9 Int) -(declare-const A0_1_3_10 Int) -(declare-const A0_1_3_5_4_7_9 Int) -(declare-const A0_1_3_5_4_8_9 Int) -(declare-const A1_3_10 Int) -(declare-const A1_3_5_4_7_9 Int) -(declare-const A1_3_5_4_8_9 Int) -(declare-const A2_3_10 Int) -(declare-const A2_3_5_4_7_9 Int) -(declare-const A2_3_5_4_8_9 Int) -(declare-const A3_10 Int) -(declare-const A3_5_4_7_9_12_13 Int) -(declare-const A3_5_4_7_9_11_13 Int) -(declare-const A3_5_4_8_9_12_13 Int) -(declare-const A3_5_4_8_9_11_13 Int) -(declare-const A4_7_9_12_13 Int) -(declare-const A4_7_9_11_13 Int) -(declare-const A4_8_9_12_13 Int) -(declare-const A4_8_9_11_13 Int) -(declare-const A5_4_7_9_12_13 Int) -(declare-const A5_4_7_9_11_13 Int) -(declare-const A5_4_8_9_12_13 Int) -(declare-const A5_4_8_9_11_13 Int) -(declare-const A6_21_10 Int) -(declare-const A6_4_7_9_12_13 Int) -(declare-const A6_4_7_9_11_13 Int) -(declare-const A6_4_8_9_12_13 Int) -(declare-const A6_4_8_9_11_13 Int) -(declare-const A7_9_12_13 Int) -(declare-const A7_9_11_13 Int) -(declare-const A8_9_12_13 Int) -(declare-const A8_9_11_13 Int) -(declare-const A9_12_13_15_17_18 Int) -(declare-const A9_12_13_15_17_16_19 Int) -(declare-const A9_12_13_14_17_18 Int) -(declare-const A9_12_13_14_17_16_19 Int) -(declare-const A9_11_13_15_17_18 Int) -(declare-const A9_11_13_15_17_16_19 Int) -(declare-const A9_11_13_14_17_18 Int) -(declare-const A9_11_13_14_17_16_19 Int) -(declare-const A11_13_15_17_18_19 Int) -(declare-const A11_13_15_17_16_19 Int) -(declare-const A11_13_14_17_18_19 Int) -(declare-const A11_13_14_17_16_19 Int) -(declare-const A12_13_15_17_18_19 Int) -(declare-const A12_13_15_17_16_19 Int) -(declare-const A12_13_14_17_18_19 Int) -(declare-const A12_13_14_17_16_19 Int) -(declare-const A13_15_17_18_19 Int) -(declare-const A13_15_17_16_19 Int) -(declare-const A13_14_17_18_19 Int) -(declare-const A13_14_17_16_19 Int) -(declare-const A20_6_21_10 Int) -(declare-const A20_6_4_7_9_12 Int) -(declare-const A20_6_4_7_9_11 Int) -(declare-const A20_6_4_8_9_12 Int) -(declare-const A20_6_4_8_9_11 Int) -(declare-const A21_10 Int) -; positive mult for each minipathlet -(assert (<= 0 A0_2_3_10)) -(assert (<= A0_2_3_10 4)) -(assert (<= 0 A0_2_3_5_4_7_9)) -(assert (<= A0_2_3_5_4_7_9 4)) -(assert (<= 0 A0_2_3_5_4_8_9)) -(assert (<= A0_2_3_5_4_8_9 4)) -(assert (<= 0 A0_1_3_10)) -(assert (<= A0_1_3_10 4)) -(assert (<= 0 A0_1_3_5_4_7_9)) -(assert (<= A0_1_3_5_4_7_9 4)) -(assert (<= 0 A0_1_3_5_4_8_9)) -(assert (<= A0_1_3_5_4_8_9 4)) -(assert (<= 0 A1_3_10)) -(assert (<= A1_3_10 4)) -(assert (<= 0 A1_3_5_4_7_9)) -(assert (<= A1_3_5_4_7_9 4)) -(assert (<= 0 A1_3_5_4_8_9)) -(assert (<= A1_3_5_4_8_9 4)) -(assert (<= 0 A2_3_10)) -(assert (<= A2_3_10 4)) -(assert (<= 0 A2_3_5_4_7_9)) -(assert (<= A2_3_5_4_7_9 4)) -(assert (<= 0 A2_3_5_4_8_9)) -(assert (<= A2_3_5_4_8_9 4)) -(assert (<= 0 A3_10)) -(assert (<= A3_10 4)) -(assert (<= 0 A3_5_4_7_9_12_13)) -(assert (<= A3_5_4_7_9_12_13 4)) -(assert (<= 0 A3_5_4_7_9_11_13)) -(assert (<= A3_5_4_7_9_11_13 4)) -(assert (<= 0 A3_5_4_8_9_12_13)) -(assert (<= A3_5_4_8_9_12_13 4)) -(assert (<= 0 A3_5_4_8_9_11_13)) -(assert (<= A3_5_4_8_9_11_13 4)) -(assert (<= 0 A4_7_9_12_13)) -(assert (<= A4_7_9_12_13 4)) -(assert (<= 0 A4_7_9_11_13)) -(assert (<= A4_7_9_11_13 4)) -(assert (<= 0 A4_8_9_12_13)) -(assert (<= A4_8_9_12_13 4)) -(assert (<= 0 A4_8_9_11_13)) -(assert (<= A4_8_9_11_13 4)) -(assert (<= 0 A5_4_7_9_12_13)) -(assert (<= A5_4_7_9_12_13 4)) -(assert (<= 0 A5_4_7_9_11_13)) -(assert (<= A5_4_7_9_11_13 4)) -(assert (<= 0 A5_4_8_9_12_13)) -(assert (<= A5_4_8_9_12_13 4)) -(assert (<= 0 A5_4_8_9_11_13)) -(assert (<= A5_4_8_9_11_13 4)) -(assert (<= 0 A6_21_10)) -(assert (<= A6_21_10 4)) -(assert (<= 0 A6_4_7_9_12_13)) -(assert (<= A6_4_7_9_12_13 4)) -(assert (<= 0 A6_4_7_9_11_13)) -(assert (<= A6_4_7_9_11_13 4)) -(assert (<= 0 A6_4_8_9_12_13)) -(assert (<= A6_4_8_9_12_13 4)) -(assert (<= 0 A6_4_8_9_11_13)) -(assert (<= A6_4_8_9_11_13 4)) -(assert (<= 0 A7_9_12_13)) -(assert (<= A7_9_12_13 4)) -(assert (<= 0 A7_9_11_13)) -(assert (<= A7_9_11_13 4)) -(assert (<= 0 A8_9_12_13)) -(assert (<= A8_9_12_13 4)) -(assert (<= 0 A8_9_11_13)) -(assert (<= A8_9_11_13 4)) -(assert (<= 0 A9_12_13_15_17_18)) -(assert (<= A9_12_13_15_17_18 4)) -(assert (<= 0 A9_12_13_15_17_16_19)) -(assert (<= A9_12_13_15_17_16_19 4)) -(assert (<= 0 A9_12_13_14_17_18)) -(assert (<= A9_12_13_14_17_18 4)) -(assert (<= 0 A9_12_13_14_17_16_19)) -(assert (<= A9_12_13_14_17_16_19 4)) -(assert (<= 0 A9_11_13_15_17_18)) -(assert (<= A9_11_13_15_17_18 4)) -(assert (<= 0 A9_11_13_15_17_16_19)) -(assert (<= A9_11_13_15_17_16_19 4)) -(assert (<= 0 A9_11_13_14_17_18)) -(assert (<= A9_11_13_14_17_18 4)) -(assert (<= 0 A9_11_13_14_17_16_19)) -(assert (<= A9_11_13_14_17_16_19 4)) -(assert (<= 0 A11_13_15_17_18_19)) -(assert (<= A11_13_15_17_18_19 4)) -(assert (<= 0 A11_13_15_17_16_19)) -(assert (<= A11_13_15_17_16_19 4)) -(assert (<= 0 A11_13_14_17_18_19)) -(assert (<= A11_13_14_17_18_19 4)) -(assert (<= 0 A11_13_14_17_16_19)) -(assert (<= A11_13_14_17_16_19 4)) -(assert (<= 0 A12_13_15_17_18_19)) -(assert (<= A12_13_15_17_18_19 4)) -(assert (<= 0 A12_13_15_17_16_19)) -(assert (<= A12_13_15_17_16_19 4)) -(assert (<= 0 A12_13_14_17_18_19)) -(assert (<= A12_13_14_17_18_19 4)) -(assert (<= 0 A12_13_14_17_16_19)) -(assert (<= A12_13_14_17_16_19 4)) -(assert (<= 0 A13_15_17_18_19)) -(assert (<= A13_15_17_18_19 4)) -(assert (<= 0 A13_15_17_16_19)) -(assert (<= A13_15_17_16_19 4)) -(assert (<= 0 A13_14_17_18_19)) -(assert (<= A13_14_17_18_19 4)) -(assert (<= 0 A13_14_17_16_19)) -(assert (<= A13_14_17_16_19 4)) -(assert (<= 0 A20_6_21_10)) -(assert (<= A20_6_21_10 4)) -(assert (<= 0 A20_6_4_7_9_12)) -(assert (<= A20_6_4_7_9_12 4)) -(assert (<= 0 A20_6_4_7_9_11)) -(assert (<= A20_6_4_7_9_11 4)) -(assert (<= 0 A20_6_4_8_9_12)) -(assert (<= A20_6_4_8_9_12 4)) -(assert (<= 0 A20_6_4_8_9_11)) -(assert (<= A20_6_4_8_9_11 4)) -(assert (<= 0 A21_10)) -(assert (<= A21_10 4)) -; range of multiplicities for each contig-pair -; contigs 0 1, #pairs 7, dist 8.36 -(assert (and (<= 0 (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) (<= (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9) 4))) -(assert-soft (= 0 (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 2.852312) ; p=0001405 -(assert-soft (= 1 (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 0.852312) ; p=0140504 -(assert-soft (= 2 (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 1.408176) ; p=0039068 -(assert-soft (= 3 (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 2.838611) ; p=0001450 -(assert-soft (= 4 (+ A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 4.627113) ; p=0000024 -; contigs 1 3, #pairs 5, dist 1.07 -(assert (and (<= 0 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) (<= (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9) 4))) -(assert-soft (= 0 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 4.168291) ; p=0000068 -(assert-soft (= 1 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 2.168291) ; p=0006787 -(assert-soft (= 2 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 1.195873) ; p=0063698 -(assert-soft (= 3 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 0.848149) ; p=0141857 -(assert-soft (= 4 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 0.756187) ; p=0175313 -; contigs 2 3, #pairs 4, dist 1.07 -(assert (and (<= 0 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) (<= (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9) 4))) -(assert-soft (= 0 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 3.535379) ; p=0000291 -(assert-soft (= 1 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 1.535379) ; p=0029149 -(assert-soft (= 2 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 0.874154) ; p=0133612 -(assert-soft (= 3 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 0.712685) ; p=0193783 -(assert-soft (= 4 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 0.755826) ; p=0175458 -; contigs 3 4, #pairs 3, dist 2.77 -(assert (and (<= 0 (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) (<= (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 5.564238) ; p=0000003 -(assert-soft (= 1 (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 3.564238) ; p=0000273 -(assert-soft (= 2 (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 2.714464) ; p=0001930 -(assert-soft (= 3 (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 2.239507) ; p=0005761 -(assert-soft (= 4 (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 1.918007) ; p=0012078 -; contigs 4 9, #pairs 2, dist 1.24 -(assert (and (<= 0 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) (<= (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 4.280499) ; p=0000052 -(assert-soft (= 1 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 2.280499) ; p=0005242 -(assert-soft (= 2 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 1.725376) ; p=0018820 -(assert-soft (= 3 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 1.420131) ; p=0038007 -(assert-soft (= 4 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 1.217191) ; p=0060647 -; contigs 5 9, #pairs 1, dist 1.46 -(assert (and (<= 0 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) (<= (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 6.000000) ; p=0000001 -(assert-soft (= 1 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 4.000000) ; p=0000100 -(assert-soft (= 2 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 6.000000) ; p=0000001 -(assert-soft (= 3 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 8.000000) ; p=0000000 -(assert-soft (= 4 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 1.0000000) ; p=0000000 -; contigs 6 9, #pairs 0, dist 2.79 -(assert (and (<= 0 (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) (<= (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.100798) ; p=0079287 -(assert-soft (= 1 (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.100798) ; p=0079287 -(assert-soft (= 2 (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.100798) ; p=0079287 -(assert-soft (= 3 (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.100798) ; p=0079287 -(assert-soft (= 4 (+ A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.100798) ; p=0079287 -; contigs 7 9, #pairs 4, dist 1.08 -(assert (and (<= 0 (+ A7_9_12_13 A7_9_11_13)) (<= (+ A7_9_12_13 A7_9_11_13) 4))) -(assert-soft (= 0 (+ A7_9_12_13 A7_9_11_13)) :dweight 4.830293) ; p=0000015 -(assert-soft (= 1 (+ A7_9_12_13 A7_9_11_13)) :dweight 2.830293) ; p=0001478 -(assert-soft (= 2 (+ A7_9_12_13 A7_9_11_13)) :dweight 1.839248) ; p=0014479 -(assert-soft (= 3 (+ A7_9_12_13 A7_9_11_13)) :dweight 1.347958) ; p=0044879 -(assert-soft (= 4 (+ A7_9_12_13 A7_9_11_13)) :dweight 1.061278) ; p=0086840 -; contigs 8 9, #pairs 2, dist 1.10 -(assert (and (<= 0 (+ A8_9_12_13 A8_9_11_13)) (<= (+ A8_9_12_13 A8_9_11_13) 4))) -(assert-soft (= 0 (+ A8_9_12_13 A8_9_11_13)) :dweight 3.085052) ; p=0000822 -(assert-soft (= 1 (+ A8_9_12_13 A8_9_11_13)) :dweight 1.085052) ; p=0082214 -(assert-soft (= 2 (+ A8_9_12_13 A8_9_11_13)) :dweight 0.712306) ; p=0193952 -(assert-soft (= 3 (+ A8_9_12_13 A8_9_11_13)) :dweight 0.589437) ; p=0257373 -(assert-soft (= 4 (+ A8_9_12_13 A8_9_11_13)) :dweight 0.568873) ; p=0269853 -; contigs 9 12, #pairs 1, dist 1.77 -(assert (and (<= 0 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19)) (<= (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19)) :dweight 2.518279) ; p=0003032 -(assert-soft (= 1 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19)) :dweight 0.518279) ; p=0303195 -(assert-soft (= 2 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19)) :dweight 0.434295) ; p=0367879 -(assert-soft (= 3 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19)) :dweight 0.475249) ; p=0334773 -(assert-soft (= 4 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19)) :dweight 0.567356) ; p=0270797 -; contigs 11 13, #pairs 2, dist 1.00 -(assert (and (<= 0 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) (<= (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 2.755831) ; p=0001755 -(assert-soft (= 1 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 0.755831) ; p=0175456 -(assert-soft (= 2 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 0.568471) ; p=0270103 -(assert-soft (= 3 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 0.630988) ; p=0233890 -(assert-soft (= 4 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 0.795810) ; p=0160026 -; contigs 12 13, #pairs 2, dist 1.01 -(assert (and (<= 0 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) (<= (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 2.662349) ; p=0002176 -(assert-soft (= 1 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 0.662349) ; p=0217596 -(assert-soft (= 2 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 0.583662) ; p=0260818 -(assert-soft (= 3 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 0.754853) ; p=0175852 -(assert-soft (= 4 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 1.028349) ; p=0093681 -; contigs 13 15, #pairs 1, dist 2.58 -(assert (and (<= 0 (+ A13_15_17_18_19 A13_15_17_16_19)) (<= (+ A13_15_17_18_19 A13_15_17_16_19) 4))) -(assert-soft (= 0 (+ A13_15_17_18_19 A13_15_17_16_19)) :dweight 2.434616) ; p=0003676 -(assert-soft (= 1 (+ A13_15_17_18_19 A13_15_17_16_19)) :dweight 0.434616) ; p=0367607 -(assert-soft (= 2 (+ A13_15_17_18_19 A13_15_17_16_19)) :dweight 0.584809) ; p=0260130 -(assert-soft (= 3 (+ A13_15_17_18_19 A13_15_17_16_19)) :dweight 0.859941) ; p=0138057 -(assert-soft (= 4 (+ A13_15_17_18_19 A13_15_17_16_19)) :dweight 1.186226) ; p=0065129 -; contigs 20 6, #pairs 7, dist 1.085 -(assert (and (<= 0 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) (<= (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11) 4))) -(assert-soft (= 0 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 2.850723) ; p=0001410 -(assert-soft (= 1 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 0.850723) ; p=0141019 -(assert-soft (= 2 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 2.181023) ; p=0006591 -(assert-soft (= 3 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 4.385894) ; p=0000041 -(assert-soft (= 4 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 6.948833) ; p=0000000 -; contigs 21 10, #pairs 1, dist 1.2 -(assert (and (<= 0 (+ A21_10)) (<= (+ A21_10) 4))) -(assert-soft (= 0 (+ A21_10)) :dweight 2.629839) ; p=0002345 -(assert-soft (= 1 (+ A21_10)) :dweight 0.629839) ; p=0234510 -(assert-soft (= 2 (+ A21_10)) :dweight 0.469677) ; p=0339096 -(assert-soft (= 3 (+ A21_10)) :dweight 0.434455) ; p=0367744 -(assert-soft (= 4 (+ A21_10)) :dweight 0.450384) ; p=0354499 -; range of multiplicities for each contig -; contig 0, length 931, #reads 41, min 0, max 4 -(assert (and (<= 0 (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) (<= (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9) 4))) -(assert-soft (= 0 (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 4.060041) ; p=0000087 -(assert-soft (= 1 (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 2.060041) ; p=0008709 -(assert-soft (= 2 (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 1.3620829) ; p=0000000 -(assert-soft (= 3 (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 3.0304105) ; p=0000000 -(assert-soft (= 4 (+ A0_2_3_10 A0_2_3_5_4_7_9 A0_2_3_5_4_8_9 A0_1_3_10 A0_1_3_5_4_7_9 A0_1_3_5_4_8_9)) :dweight 4.9084634) ; p=0000000 -; contig 1, length 195, #reads 16, min 0, max 4 -(assert (and (<= 0 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) (<= (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9) 4))) -(assert-soft (= 0 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 5.312217) ; p=0000005 -(assert-soft (= 1 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 3.312217) ; p=0000487 -(assert-soft (= 2 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 1.202826) ; p=0062686 -(assert-soft (= 3 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 1.092455) ; p=0080825 -(assert-soft (= 4 (+ A1_3_10 A1_3_5_4_7_9 A1_3_5_4_8_9)) :dweight 1.800524) ; p=0015830 -; contig 2, length 198, #reads 21, min 0, max 4 -(assert (and (<= 0 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) (<= (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9) 4))) -(assert-soft (= 0 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 7.526226) ; p=0000000 -(assert-soft (= 1 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 5.526226) ; p=0000003 -(assert-soft (= 2 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 1.998081) ; p=0010044 -(assert-soft (= 3 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 1.093650) ; p=0080603 -(assert-soft (= 4 (+ A2_3_10 A2_3_5_4_7_9 A2_3_5_4_8_9)) :dweight 1.263422) ; p=0054523 -; contig 3, length 347, #reads 56, min 0, max 4 -(assert (and (<= 0 (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) (<= (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 1.6034953) ; p=0000000 -(assert-soft (= 1 (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 1.4034953) ; p=0000000 -(assert-soft (= 2 (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 4.261782) ; p=0000055 -(assert-soft (= 3 (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 1.485181) ; p=0032720 -(assert-soft (= 4 (+ A3_10 A3_5_4_7_9_12_13 A3_5_4_7_9_11_13 A3_5_4_8_9_12_13 A3_5_4_8_9_11_13)) :dweight 1.573120) ; p=0026723 -; contig 4, length 113, #reads 8, min 0, max 4 -(assert (and (<= 0 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) (<= (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 7.744934) ; p=0000000 -(assert-soft (= 1 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 5.744934) ; p=0000002 -(assert-soft (= 2 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 3.682280) ; p=0000208 -(assert-soft (= 3 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 2.619135) ; p=0002404 -(assert-soft (= 4 (+ A4_7_9_12_13 A4_7_9_11_13 A4_8_9_12_13 A4_8_9_11_13)) :dweight 1.965211) ; p=0010834 -; contig 5, length 101, #reads 2, min 0, max 4 -(assert (and (<= 0 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) (<= (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 4.686648) ; p=0000021 -(assert-soft (= 1 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 2.686648) ; p=0002058 -(assert-soft (= 2 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 2.113387) ; p=0007702 -(assert-soft (= 3 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 1.790003) ; p=0016218 -(assert-soft (= 4 (+ A5_4_7_9_12_13 A5_4_7_9_11_13 A5_4_8_9_12_13 A5_4_8_9_11_13)) :dweight 1.568925) ; p=0026982 -; contig 6, length 223, #reads 24, min 0, max 4 -(assert (and (<= 0 (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) (<= (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13) 4))) -(assert-soft (= 0 (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 7.515357) ; p=0000000 -(assert-soft (= 1 (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 5.515357) ; p=0000003 -(assert-soft (= 2 (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.804093) ; p=0015700 -(assert-soft (= 3 (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.091359) ; p=0081029 -(assert-soft (= 4 (+ A6_21_10 A6_4_7_9_12_13 A6_4_7_9_11_13 A6_4_8_9_12_13 A6_4_8_9_11_13)) :dweight 1.606284) ; p=0024758 -; contig 7, length 191, #reads 9, min 0, max 4 -(assert (and (<= 0 (+ A7_9_12_13 A7_9_11_13)) (<= (+ A7_9_12_13 A7_9_11_13) 4))) -(assert-soft (= 0 (+ A7_9_12_13 A7_9_11_13)) :dweight 3.169161) ; p=0000677 -(assert-soft (= 1 (+ A7_9_12_13 A7_9_11_13)) :dweight 1.169161) ; p=0067739 -(assert-soft (= 2 (+ A7_9_12_13 A7_9_11_13)) :dweight 1.051784) ; p=0088760 -(assert-soft (= 3 (+ A7_9_12_13 A7_9_11_13)) :dweight 2.058857) ; p=0008733 -(assert-soft (= 4 (+ A7_9_12_13 A7_9_11_13)) :dweight 3.526301) ; p=0000298 -; contig 8, length 200, #reads 12, min 0, max 4 -(assert (and (<= 0 (+ A8_9_12_13 A8_9_11_13)) (<= (+ A8_9_12_13 A8_9_11_13) 4))) -(assert-soft (= 0 (+ A8_9_12_13 A8_9_11_13)) :dweight 3.724714) ; p=0000188 -(assert-soft (= 1 (+ A8_9_12_13 A8_9_11_13)) :dweight 1.724714) ; p=0018849 -(assert-soft (= 2 (+ A8_9_12_13 A8_9_11_13)) :dweight 0.963436) ; p=0108784 -(assert-soft (= 3 (+ A8_9_12_13 A8_9_11_13)) :dweight 1.701424) ; p=0019887 -(assert-soft (= 4 (+ A8_9_12_13 A8_9_11_13)) :dweight 3.053242) ; p=0000885 -; contig 9, length 269, #reads 32, min 0, max 4 -(assert (and (<= 0 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19)) (<= (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19)) :dweight 8.757585) ; p=0000000 -(assert-soft (= 1 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19)) :dweight 6.757585) ; p=0000000 -(assert-soft (= 2 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19)) :dweight 1.962827) ; p=0010894 -(assert-soft (= 3 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19)) :dweight 1.166108) ; p=0068217 -(assert-soft (= 4 (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19 A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19)) :dweight 2.006269) ; p=0009857 -; contig 11, length 170, #reads 7, min 0, max 4 -(assert (and (<= 0 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) (<= (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 3.066473) ; p=0000858 -(assert-soft (= 1 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 1.066473) ; p=0085808 -(assert-soft (= 2 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 0.946381) ; p=0113141 -(assert-soft (= 3 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 1.700861) ; p=0019913 -(assert-soft (= 4 (+ A11_13_15_17_18_19 A11_13_15_17_16_19 A11_13_14_17_18_19 A11_13_14_17_16_19)) :dweight 2.813408) ; p=0001537 -; contig 12, length 198, #reads 15, min 0, max 4 -(assert (and (<= 0 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) (<= (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 4.784554) ; p=0000016 -(assert-soft (= 1 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 2.784554) ; p=0001642 -(assert-soft (= 2 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 1.062589) ; p=0086579 -(assert-soft (= 3 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 1.214705) ; p=0060995 -(assert-soft (= 4 (+ A12_13_15_17_18_19 A12_13_15_17_16_19 A12_13_14_17_18_19 A12_13_14_17_16_19)) :dweight 2.134110) ; p=0007343 -; contig 13, length 349, #reads 28, min 0, max 4 -(assert (and (<= 0 (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19)) (<= (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19) 4))) -(assert-soft (= 0 (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19)) :dweight 4.577071) ; p=0000026 -(assert-soft (= 1 (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19)) :dweight 2.577071) ; p=0002648 -(assert-soft (= 2 (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19)) :dweight 1.290338) ; p=0051246 -(assert-soft (= 3 (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19)) :dweight 3.501889) ; p=0000315 -(assert-soft (= 4 (+ A13_15_17_18_19 A13_15_17_16_19 A13_14_17_18_19 A13_14_17_16_19)) :dweight 7.145711) ; p=0000000 -; contig 20, length 1151, #reads 32, min 0, max 4 -(assert (and (<= 0 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) (<= (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11) 4))) -(assert-soft (= 0 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 8.689981) ; p=0000000 -(assert-soft (= 1 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 6.689981) ; p=0000000 -(assert-soft (= 2 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 2.7295778) ; p=0000000 -(assert-soft (= 3 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 5.1899615) ; p=0000000 -(assert-soft (= 4 (+ A20_6_21_10 A20_6_4_7_9_12 A20_6_4_7_9_11 A20_6_4_8_9_12 A20_6_4_8_9_11)) :dweight 7.8140332) ; p=0000000 -; contig 21, length 107, #reads 4, min 0, max 4 -(assert (and (<= 0 (+ A21_10)) (<= (+ A21_10) 4))) -(assert-soft (= 0 (+ A21_10)) :dweight 5.154038) ; p=0000007 -(assert-soft (= 1 (+ A21_10)) :dweight 3.154038) ; p=0000701 -(assert-soft (= 2 (+ A21_10)) :dweight 2.122711) ; p=0007539 -(assert-soft (= 3 (+ A21_10)) :dweight 1.591139) ; p=0025637 -(assert-soft (= 4 (+ A21_10)) :dweight 1.264177) ; p=0054428 -; consistency of minipathlet multiplicities -(assert (= (+ A9_12_13_15_17_18) (+ A12_13_15_17_18_19))) -(assert (= (+ A5_4_7_9_11_13 A6_4_7_9_11_13) (+ A4_7_9_11_13))) -(assert (= (+ A0_2_3_5_4_8_9) (+ A2_3_5_4_8_9))) -(assert (= (+ A1_3_5_4_8_9 A2_3_5_4_8_9) (+ A3_5_4_8_9_12_13 A3_5_4_8_9_11_13))) -(assert (= (+ A9_11_13_14_17_16_19) (+ A11_13_14_17_16_19))) -(assert (= (+ A11_13_14_17_16_19 A12_13_14_17_16_19) (+ A13_14_17_16_19))) -(assert (= (+ A20_6_21_10) (+ A6_21_10))) -(assert (= (+ A11_13_14_17_18_19 A12_13_14_17_18_19) (+ A13_14_17_18_19))) -(assert (= (+ A0_1_3_5_4_7_9) (+ A1_3_5_4_7_9))) -(assert (= (+ A9_12_13_14_17_18) (+ A12_13_14_17_18_19))) -(assert (= (+ A1_3_10 A2_3_10) (+ A3_10))) -(assert (= (+ A11_13_15_17_18_19 A12_13_15_17_18_19) (+ A13_15_17_18_19))) -(assert (= (+ A11_13_15_17_16_19 A12_13_15_17_16_19) (+ A13_15_17_16_19))) -(assert (= (+ A9_12_13_14_17_16_19) (+ A12_13_14_17_16_19))) -(assert (= (+ A7_9_11_13 A8_9_11_13) (+ A9_11_13_15_17_18 A9_11_13_15_17_16_19 A9_11_13_14_17_18 A9_11_13_14_17_16_19))) -(assert (= (+ A0_2_3_5_4_7_9) (+ A2_3_5_4_7_9))) -(assert (= (+ A4_8_9_11_13) (+ A8_9_11_13))) -(assert (= (+ A0_1_3_10) (+ A1_3_10))) -(assert (= (+ A20_6_4_8_9_12) (+ A6_4_8_9_12_13))) -(assert (= (+ A3_5_4_8_9_11_13) (+ A5_4_8_9_11_13))) -(assert (= (+ A0_1_3_5_4_8_9) (+ A1_3_5_4_8_9))) -(assert (= (+ A5_4_8_9_11_13 A6_4_8_9_11_13) (+ A4_8_9_11_13))) -(assert (= (+ A20_6_4_7_9_12) (+ A6_4_7_9_12_13))) -(assert (= (+ A20_6_4_7_9_11) (+ A6_4_7_9_11_13))) -(assert (= (+ A3_5_4_8_9_12_13) (+ A5_4_8_9_12_13))) -(assert (= (+ A4_7_9_12_13) (+ A7_9_12_13))) -(assert (= (+ A9_12_13_15_17_16_19) (+ A12_13_15_17_16_19))) -(assert (= (+ A9_11_13_15_17_16_19) (+ A11_13_15_17_16_19))) -(assert (= (+ A1_3_5_4_7_9 A2_3_5_4_7_9) (+ A3_5_4_7_9_12_13 A3_5_4_7_9_11_13))) -(assert (= (+ A3_5_4_7_9_12_13) (+ A5_4_7_9_12_13))) -(assert (= (+ A7_9_12_13 A8_9_12_13) (+ A9_12_13_15_17_18 A9_12_13_15_17_16_19 A9_12_13_14_17_18 A9_12_13_14_17_16_19))) -(assert (= (+ A0_2_3_10) (+ A2_3_10))) -(assert (= (+ A9_11_13_14_17_18) (+ A11_13_14_17_18_19))) -(assert (= (+ A4_8_9_12_13) (+ A8_9_12_13))) -(assert (= (+ A5_4_7_9_12_13 A6_4_7_9_12_13) (+ A4_7_9_12_13))) -(assert (= (+ A9_11_13_15_17_18) (+ A11_13_15_17_18_19))) -(assert (= (+ A6_21_10) (+ A21_10))) -(assert (= (+ A20_6_4_8_9_11) (+ A6_4_8_9_11_13))) -(assert (= (+ A3_5_4_7_9_11_13) (+ A5_4_7_9_11_13))) -(assert (= (+ A5_4_8_9_12_13 A6_4_8_9_12_13) (+ A4_8_9_12_13))) -(assert (= (+ A4_7_9_11_13) (+ A7_9_11_13))) -(optimize :print_statistics true - :wmaxsat_engine sls - :maxsat_engine weighted_maxsat) diff --git a/tests/sls1.smt2 b/tests/sls1.smt2 deleted file mode 100644 index 5f38a941858..00000000000 --- a/tests/sls1.smt2 +++ /dev/null @@ -1,5844 +0,0 @@ -(set-option :smt.relevancy 0) -(set-option :smt.pb.conflict_frequency 10000) -(declare-fun x_354 () Int) -(declare-fun x_522 () Int) -(declare-fun x_464 () Int) -(declare-fun x_644 () Int) -(declare-fun x_174 () Int) -(declare-fun x_397 () Int) -(declare-fun x_432 () Int) -(declare-fun x_557 () Int) -(declare-fun x_926 () Int) -(declare-fun x_582 () Int) -(declare-fun x_779 () Int) -(declare-fun x_759 () Int) -(declare-fun x_912 () Int) -(declare-fun x_868 () Int) -(declare-fun x_384 () Int) -(declare-fun x_963 () Int) -(declare-fun x_658 () Int) -(declare-fun x_362 () Int) -(declare-fun x_984 () Int) -(declare-fun x_308 () Int) -(declare-fun x_456 () Int) -(declare-fun x_17 () Int) -(declare-fun x_816 () Int) -(declare-fun x_833 () Int) -(declare-fun x_463 () Int) -(declare-fun x_211 () Int) -(declare-fun x_607 () Int) -(declare-fun x_139 () Int) -(declare-fun x_124 () Int) -(declare-fun x_291 () Int) -(declare-fun x_859 () Int) -(declare-fun x_888 () Int) -(declare-fun x_31 () Int) -(declare-fun x_472 () Int) -(declare-fun x_434 () Int) -(declare-fun x_154 () Int) -(declare-fun x_347 () Int) -(declare-fun x_88 () Int) -(declare-fun x_769 () Int) -(declare-fun x_986 () Int) -(declare-fun x_8 () Int) -(declare-fun x_196 () Int) -(declare-fun x_882 () Int) -(declare-fun x_711 () Int) -(declare-fun x_167 () Int) -(declare-fun x_119 () Int) -(declare-fun x_4 () Int) -(declare-fun x_33 () Int) -(declare-fun x_178 () Int) -(declare-fun x_893 () Int) -(declare-fun x_429 () Int) -(declare-fun x_527 () Int) -(declare-fun x_194 () Int) -(declare-fun x_498 () Int) -(declare-fun x_346 () Int) -(declare-fun x_712 () Int) -(declare-fun x_691 () Int) -(declare-fun x_294 () Int) -(declare-fun x_402 () Int) -(declare-fun x_213 () Int) -(declare-fun x_239 () Int) -(declare-fun x_297 () Int) -(declare-fun x_427 () Int) -(declare-fun x_489 () Int) -(declare-fun x_841 () Int) -(declare-fun x_186 () Int) -(declare-fun x_149 () Int) -(declare-fun x_586 () Int) -(declare-fun x_932 () Int) -(declare-fun x_367 () Int) -(declare-fun x_77 () Int) -(declare-fun x_123 () Int) -(declare-fun x_884 () Int) -(declare-fun x_989 () Int) -(declare-fun x_242 () Int) -(declare-fun x_614 () Int) -(declare-fun x_381 () Int) -(declare-fun x_388 () Int) -(declare-fun x_306 () Int) -(declare-fun x_737 () Int) -(declare-fun x_277 () Int) -(declare-fun x_966 () Int) -(declare-fun x_67 () Int) -(declare-fun x_678 () Int) -(declare-fun x_87 () Int) -(declare-fun x_496 () Int) -(declare-fun x_919 () Int) -(declare-fun x_439 () Int) -(declare-fun x_854 () Int) -(declare-fun x_961 () Int) -(declare-fun x_697 () Int) -(declare-fun x_19 () Int) -(declare-fun x_818 () Int) -(declare-fun x_158 () Int) -(declare-fun x_26 () Int) -(declare-fun x_436 () Int) -(declare-fun x_798 () Int) -(declare-fun x_457 () Int) -(declare-fun x_838 () Int) -(declare-fun x_953 () Int) -(declare-fun x_524 () Int) -(declare-fun x_574 () Int) -(declare-fun x_212 () Int) -(declare-fun x_486 () Int) -(declare-fun x_3 () Int) -(declare-fun x_256 () Int) -(declare-fun x_22 () Int) -(declare-fun x_676 () Int) -(declare-fun x_789 () Int) -(declare-fun x_892 () Int) -(declare-fun x_682 () Int) -(declare-fun x_84 () Int) -(declare-fun x_819 () Int) -(declare-fun x_454 () Int) -(declare-fun x_59 () Int) -(declare-fun x_227 () Int) -(declare-fun x_572 () Int) -(declare-fun x_914 () Int) -(declare-fun x_39 () Int) -(declare-fun x_679 () Int) -(declare-fun x_824 () Int) -(declare-fun x_684 () Int) -(declare-fun x_221 () Int) -(declare-fun x_274 () Int) -(declare-fun x_32 () Int) -(declare-fun x_348 () Int) -(declare-fun x_877 () Int) -(declare-fun x_701 () Int) -(declare-fun x_231 () Int) -(declare-fun x_549 () Int) -(declare-fun x_889 () Int) -(declare-fun x_879 () Int) -(declare-fun x_662 () Int) -(declare-fun x_302 () Int) -(declare-fun x_979 () Int) -(declare-fun x_861 () Int) -(declare-fun x_973 () Int) -(declare-fun x_401 () Int) -(declare-fun x_537 () Int) -(declare-fun x_972 () Int) -(declare-fun x_269 () Int) -(declare-fun x_957 () Int) -(declare-fun x_271 () Int) -(declare-fun x_363 () Int) -(declare-fun x_181 () Int) -(declare-fun x_357 () Int) -(declare-fun x_591 () Int) -(declare-fun x_559 () Int) -(declare-fun x_51 () Int) -(declare-fun x_916 () Int) -(declare-fun x_389 () Int) -(declare-fun x_512 () Int) -(declare-fun x_988 () Int) -(declare-fun x_667 () Int) -(declare-fun x_511 () Int) -(declare-fun x_733 () Int) -(declare-fun x_821 () Int) -(declare-fun x_671 () Int) -(declare-fun x_707 () Int) -(declare-fun x_826 () Int) -(declare-fun x_319 () Int) -(declare-fun x_399 () Int) -(declare-fun x_852 () Int) -(declare-fun x_442 () Int) -(declare-fun x_108 () Int) -(declare-fun x_392 () Int) -(declare-fun x_776 () Int) -(declare-fun x_993 () Int) -(declare-fun x_459 () Int) -(declare-fun x_913 () Int) -(declare-fun x_107 () Int) -(declare-fun x_994 () Int) -(declare-fun x_61 () Int) -(declare-fun x_802 () Int) -(declare-fun x_677 () Int) -(declare-fun x_857 () Int) -(declare-fun x_706 () Int) -(declare-fun x_278 () Int) -(declare-fun x_443 () Int) -(declare-fun x_813 () Int) -(declare-fun x_971 () Int) -(declare-fun x_173 () Int) -(declare-fun x_91 () Int) -(declare-fun x_396 () Int) -(declare-fun x_551 () Int) -(declare-fun x_846 () Int) -(declare-fun x_417 () Int) -(declare-fun x_54 () Int) -(declare-fun x_721 () Int) -(declare-fun x_331 () Int) -(declare-fun x_467 () Int) -(declare-fun x_553 () Int) -(declare-fun x_959 () Int) -(declare-fun x_871 () Int) -(declare-fun x_692 () Int) -(declare-fun x_792 () Int) -(declare-fun x_593 () Int) -(declare-fun x_412 () Int) -(declare-fun x_531 () Int) -(declare-fun x_352 () Int) -(declare-fun x_333 () Int) -(declare-fun x_596 () Int) -(declare-fun x_229 () Int) -(declare-fun x_447 () Int) -(declare-fun x_53 () Int) -(declare-fun x_548 () Int) -(declare-fun x_43 () Int) -(declare-fun x_13 () Int) -(declare-fun x_198 () Int) -(declare-fun x_47 () Int) -(declare-fun x_626 () Int) -(declare-fun x_648 () Int) -(declare-fun x_902 () Int) -(declare-fun x_594 () Int) -(declare-fun x_113 () Int) -(declare-fun x_286 () Int) -(declare-fun x_163 () Int) -(declare-fun x_157 () Int) -(declare-fun x_659 () Int) -(declare-fun x_24 () Int) -(declare-fun x_631 () Int) -(declare-fun x_699 () Int) -(declare-fun x_366 () Int) -(declare-fun x_6 () Int) -(declare-fun x_156 () Int) -(declare-fun x_876 () Int) -(declare-fun x_598 () Int) -(declare-fun x_974 () Int) -(declare-fun x_372 () Int) -(declare-fun x_538 () Int) -(declare-fun x_287 () Int) -(declare-fun x_71 () Int) -(declare-fun x_371 () Int) -(declare-fun x_646 () Int) -(declare-fun x_519 () Int) -(declare-fun x_121 () Int) -(declare-fun x_268 () Int) -(declare-fun x_746 () Int) -(declare-fun x_562 () Int) -(declare-fun x_799 () Int) -(declare-fun x_423 () Int) -(declare-fun x_808 () Int) -(declare-fun x_303 () Int) -(declare-fun x_536 () Int) -(declare-fun x_344 () Int) -(declare-fun x_322 () Int) -(declare-fun x_299 () Int) -(declare-fun x_976 () Int) -(declare-fun x_279 () Int) -(declare-fun x_482 () Int) -(declare-fun x_246 () Int) -(declare-fun x_763 () Int) -(declare-fun x_111 () Int) -(declare-fun x_226 () Int) -(declare-fun x_741 () Int) -(declare-fun x_188 () Int) -(declare-fun x_873 () Int) -(declare-fun x_767 () Int) -(declare-fun x_766 () Int) -(declare-fun x_7 () Int) -(declare-fun x_377 () Int) -(declare-fun x_719 () Int) -(declare-fun x_704 () Int) -(declare-fun x_72 () Int) -(declare-fun x_27 () Int) -(declare-fun x_284 () Int) -(declare-fun x_943 () Int) -(declare-fun x_42 () Int) -(declare-fun x_881 () Int) -(declare-fun x_693 () Int) -(declare-fun x_422 () Int) -(declare-fun x_218 () Int) -(declare-fun x_736 () Int) -(declare-fun x_817 () Int) -(declare-fun x_168 () Int) -(declare-fun x_359 () Int) -(declare-fun x_16 () Int) -(declare-fun x_469 () Int) -(declare-fun x_814 () Int) -(declare-fun x_62 () Int) -(declare-fun x_461 () Int) -(declare-fun x_483 () Int) -(declare-fun x_68 () Int) -(declare-fun x_786 () Int) -(declare-fun x_938 () Int) -(declare-fun x_204 () Int) -(declare-fun x_718 () Int) -(declare-fun x_197 () Int) -(declare-fun x_603 () Int) -(declare-fun x_616 () Int) -(declare-fun x_117 () Int) -(declare-fun x_567 () Int) -(declare-fun x_729 () Int) -(declare-fun x_942 () Int) -(declare-fun x_748 () Int) -(declare-fun x_992 () Int) -(declare-fun x_713 () Int) -(declare-fun x_326 () Int) -(declare-fun x_689 () Int) -(declare-fun x_948 () Int) -(declare-fun x_717 () Int) -(declare-fun x_403 () Int) -(declare-fun x_872 () Int) -(declare-fun x_73 () Int) -(declare-fun x_639 () Int) -(declare-fun x_137 () Int) -(declare-fun x_373 () Int) -(declare-fun x_364 () Int) -(declare-fun x_576 () Int) -(declare-fun x_358 () Int) -(declare-fun x_466 () Int) -(declare-fun x_122 () Int) -(declare-fun x_637 () Int) -(declare-fun x_202 () Int) -(declare-fun x_476 () Int) -(declare-fun x_44 () Int) -(declare-fun x_151 () Int) -(declare-fun x_253 () Int) -(declare-fun x_696 () Int) -(declare-fun x_822 () Int) -(declare-fun x_641 () Int) -(declare-fun x_924 () Int) -(declare-fun x_233 () Int) -(declare-fun x_136 () Int) -(declare-fun x_222 () Int) -(declare-fun x_318 () Int) -(declare-fun x_694 () Int) -(declare-fun x_543 () Int) -(declare-fun x_141 () Int) -(declare-fun x_418 () Int) -(declare-fun x_409 () Int) -(declare-fun x_601 () Int) -(declare-fun x_339 () Int) -(declare-fun x_958 () Int) -(declare-fun x_773 () Int) -(declare-fun x_448 () Int) -(declare-fun x_508 () Int) -(declare-fun x_104 () Int) -(declare-fun x_674 () Int) -(declare-fun x_991 () Int) -(declare-fun x_406 () Int) -(declare-fun x_283 () Int) -(declare-fun x_552 () Int) -(declare-fun x_907 () Int) -(declare-fun x_408 () Int) -(declare-fun x_451 () Int) -(declare-fun x_897 () Int) -(declare-fun x_503 () Int) -(declare-fun x_672 () Int) -(declare-fun x_264 () Int) -(declare-fun x_382 () Int) -(declare-fun x_554 () Int) -(declare-fun x_561 () Int) -(declare-fun x_11 () Int) -(declare-fun x_329 () Int) -(declare-fun x_727 () Int) -(declare-fun x_97 () Int) -(declare-fun x_343 () Int) -(declare-fun x_918 () Int) -(declare-fun x_289 () Int) -(declare-fun x_803 () Int) -(declare-fun x_812 () Int) -(declare-fun x_547 () Int) -(declare-fun x_806 () Int) -(declare-fun x_252 () Int) -(declare-fun x_273 () Int) -(declare-fun x_618 () Int) -(declare-fun x_301 () Int) -(declare-fun x_688 () Int) -(declare-fun x_224 () Int) -(declare-fun x_449 () Int) -(declare-fun x_327 () Int) -(declare-fun x_387 () Int) -(declare-fun x_86 () Int) -(declare-fun x_89 () Int) -(declare-fun x_404 () Int) -(declare-fun x_507 () Int) -(declare-fun x_312 () Int) -(declare-fun x_578 () Int) -(declare-fun x_722 () Int) -(declare-fun x_762 () Int) -(declare-fun x_169 () Int) -(declare-fun x_206 () Int) -(declare-fun x_383 () Int) -(declare-fun x_867 () Int) -(declare-fun x_627 () Int) -(declare-fun x_638 () Int) -(declare-fun x_184 () Int) -(declare-fun x_479 () Int) -(declare-fun x_292 () Int) -(declare-fun x_844 () Int) -(declare-fun x_421 () Int) -(declare-fun x_911 () Int) -(declare-fun x_419 () Int) -(declare-fun x_612 () Int) -(declare-fun x_192 () Int) -(declare-fun x_656 () Int) -(declare-fun x_702 () Int) -(declare-fun x_778 () Int) -(declare-fun x_281 () Int) -(declare-fun x_834 () Int) -(declare-fun x_63 () Int) -(declare-fun x_836 () Int) -(declare-fun x_793 () Int) -(declare-fun x_622 () Int) -(declare-fun x_899 () Int) -(declare-fun x_944 () Int) -(declare-fun x_369 () Int) -(declare-fun x_336 () Int) -(declare-fun x_869 () Int) -(declare-fun x_257 () Int) -(declare-fun x_1001 () Int) -(declare-fun x_904 () Int) -(declare-fun x_528 () Int) -(declare-fun x_997 () Int) -(declare-fun x_414 () Int) -(declare-fun x_223 () Int) -(declare-fun x_642 () Int) -(declare-fun x_76 () Int) -(declare-fun x_29 () Int) -(declare-fun x_533 () Int) -(declare-fun x_41 () Int) -(declare-fun x_581 () Int) -(declare-fun x_791 () Int) -(declare-fun x_809 () Int) -(declare-fun x_321 () Int) -(declare-fun x_939 () Int) -(declare-fun x_541 () Int) -(declare-fun x_652 () Int) -(declare-fun x_569 () Int) -(declare-fun x_934 () Int) -(declare-fun x_207 () Int) -(declare-fun x_376 () Int) -(declare-fun x_109 () Int) -(declare-fun x_761 () Int) -(declare-fun x_446 () Int) -(declare-fun x_657 () Int) -(declare-fun x_171 () Int) -(declare-fun x_558 () Int) -(declare-fun x_276 () Int) -(declare-fun x_46 () Int) -(declare-fun x_668 () Int) -(declare-fun x_57 () Int) -(declare-fun x_374 () Int) -(declare-fun x_209 () Int) -(declare-fun x_739 () Int) -(declare-fun x_909 () Int) -(declare-fun x_468 () Int) -(declare-fun x_14 () Int) -(declare-fun x_832 () Int) -(declare-fun x_391 () Int) -(declare-fun x_517 () Int) -(declare-fun x_12 () Int) -(declare-fun x_244 () Int) -(declare-fun x_628 () Int) -(declare-fun x_334 () Int) -(declare-fun x_502 () Int) -(declare-fun x_883 () Int) -(declare-fun x_379 () Int) -(declare-fun x_307 () Int) -(declare-fun x_182 () Int) -(declare-fun x_293 () Int) -(declare-fun x_288 () Int) -(declare-fun x_633 () Int) -(declare-fun x_866 () Int) -(declare-fun x_571 () Int) -(declare-fun x_842 () Int) -(declare-fun x_921 () Int) -(declare-fun x_797 () Int) -(declare-fun x_153 () Int) -(declare-fun x_398 () Int) -(declare-fun x_583 () Int) -(declare-fun x_683 () Int) -(declare-fun x_189 () Int) -(declare-fun x_964 () Int) -(declare-fun x_164 () Int) -(declare-fun x_474 () Int) -(declare-fun x_521 () Int) -(declare-fun x_21 () Int) -(declare-fun x_518 () Int) -(declare-fun x_473 () Int) -(declare-fun x_896 () Int) -(declare-fun x_796 () Int) -(declare-fun x_477 () Int) -(declare-fun x_74 () Int) -(declare-fun x_116 () Int) -(declare-fun x_837 () Int) -(declare-fun x_673 () Int) -(declare-fun x_309 () Int) -(declare-fun x_58 () Int) -(declare-fun x_428 () Int) -(declare-fun x_589 () Int) -(declare-fun x_747 () Int) -(declare-fun x_929 () Int) -(declare-fun x_529 () Int) -(declare-fun x_413 () Int) -(declare-fun x_847 () Int) -(declare-fun x_262 () Int) -(declare-fun x_801 () Int) -(declare-fun x_952 () Int) -(declare-fun x_632 () Int) -(declare-fun x_142 () Int) -(declare-fun x_491 () Int) -(declare-fun x_546 () Int) -(declare-fun x_839 () Int) -(declare-fun x_588 () Int) -(declare-fun x_393 () Int) -(declare-fun x_118 () Int) -(declare-fun x_901 () Int) -(declare-fun x_962 () Int) -(declare-fun x_968 () Int) -(declare-fun x_886 () Int) -(declare-fun x_774 () Int) -(declare-fun x_487 () Int) -(declare-fun x_127 () Int) -(declare-fun x_237 () Int) -(declare-fun x_723 () Int) -(declare-fun x_542 () Int) -(declare-fun x_753 () Int) -(declare-fun x_129 () Int) -(declare-fun x_864 () Int) -(declare-fun x_611 () Int) -(declare-fun x_416 () Int) -(declare-fun x_947 () Int) -(declare-fun x_1202 () Int) -(declare-fun x_563 () Int) -(declare-fun x_337 () Int) -(declare-fun x_544 () Int) -(declare-fun x_654 () Int) -(declare-fun x_756 () Int) -(declare-fun x_744 () Int) -(declare-fun x_891 () Int) -(declare-fun x_378 () Int) -(declare-fun x_134 () Int) -(declare-fun x_208 () Int) -(declare-fun x_758 () Int) -(declare-fun x_848 () Int) -(declare-fun x_927 () Int) -(declare-fun x_937 () Int) -(declare-fun x_602 () Int) -(declare-fun x_349 () Int) -(declare-fun x_96 () Int) -(declare-fun x_162 () Int) -(declare-fun x_37 () Int) -(declare-fun x_941 () Int) -(declare-fun x_906 () Int) -(declare-fun x_811 () Int) -(declare-fun x_138 () Int) -(declare-fun x_621 () Int) -(declare-fun x_492 () Int) -(declare-fun x_764 () Int) -(declare-fun x_452 () Int) -(declare-fun x_851 () Int) -(declare-fun x_98 () Int) -(declare-fun x_236 () Int) -(declare-fun x_453 () Int) -(declare-fun x_978 () Int) -(declare-fun x_499 () Int) -(declare-fun x_494 () Int) -(declare-fun x_316 () Int) -(declare-fun x_587 () Int) -(declare-fun x_103 () Int) -(declare-fun x_734 () Int) -(declare-fun x_923 () Int) -(declare-fun x_228 () Int) -(declare-fun x_504 () Int) -(declare-fun x_564 () Int) -(declare-fun x_592 () Int) -(declare-fun x_2 () Int) -(declare-fun x_539 () Int) -(declare-fun x_247 () Int) -(declare-fun x_931 () Int) -(declare-fun x_903 () Int) -(declare-fun x_64 () Int) -(declare-fun x_232 () Int) -(declare-fun x_298 () Int) -(declare-fun x_126 () Int) -(declare-fun x_787 () Int) -(declare-fun x_243 () Int) -(declare-fun x_356 () Int) -(declare-fun x_709 () Int) -(declare-fun x_823 () Int) -(declare-fun x_338 () Int) -(declare-fun x_201 () Int) -(declare-fun x_304 () Int) -(declare-fun x_101 () Int) -(declare-fun x_568 () Int) -(declare-fun x_573 () Int) -(declare-fun x_28 () Int) -(declare-fun x_516 () Int) -(declare-fun x_619 () Int) -(declare-fun x_102 () Int) -(declare-fun x_92 () Int) -(declare-fun x_604 () Int) -(declare-fun x_597 () Int) -(declare-fun x_663 () Int) -(declare-fun x_731 () Int) -(declare-fun x_328 () Int) -(declare-fun x_143 () Int) -(declare-fun x_849 () Int) -(declare-fun x_128 () Int) -(declare-fun x_266 () Int) -(declare-fun x_203 () Int) -(declare-fun x_661 () Int) -(declare-fun x_996 () Int) -(declare-fun x_462 () Int) -(declare-fun x_977 () Int) -(declare-fun x_458 () Int) -(declare-fun x_933 () Int) -(declare-fun x_94 () Int) -(declare-fun x_332 () Int) -(declare-fun x_514 () Int) -(declare-fun x_969 () Int) -(declare-fun x_987 () Int) -(declare-fun x_497 () Int) -(declare-fun x_666 () Int) -(declare-fun x_858 () Int) -(declare-fun x_643 () Int) -(declare-fun x_523 () Int) -(declare-fun x_609 () Int) -(declare-fun x_263 () Int) -(declare-fun x_878 () Int) -(declare-fun x_981 () Int) -(declare-fun x_863 () Int) -(declare-fun x_324 () Int) -(declare-fun x_783 () Int) -(declare-fun x_241 () Int) -(declare-fun x_407 () Int) -(declare-fun x_708 () Int) -(declare-fun x_862 () Int) -(declare-fun x_757 () Int) -(declare-fun x_251 () Int) -(declare-fun x_771 () Int) -(declare-fun x_478 () Int) -(declare-fun x_437 () Int) -(declare-fun x_267 () Int) -(declare-fun x_599 () Int) -(declare-fun x_234 () Int) -(declare-fun x_177 () Int) -(declare-fun x_726 () Int) -(declare-fun x_261 () Int) -(declare-fun x_353 () Int) -(declare-fun x_732 () Int) -(declare-fun x_908 () Int) -(declare-fun x_361 () Int) -(declare-fun x_887 () Int) -(declare-fun x_488 () Int) -(declare-fun x_917 () Int) -(declare-fun x_716 () Int) -(declare-fun x_166 () Int) -(declare-fun x_112 () Int) -(declare-fun x_629 () Int) -(declare-fun x_52 () Int) -(declare-fun x_34 () Int) -(declare-fun x_183 () Int) -(declare-fun x_999 () Int) -(declare-fun x_99 () Int) -(declare-fun x_444 () Int) -(declare-fun x_424 () Int) -(declare-fun x_317 () Int) -(declare-fun x_784 () Int) -(declare-fun x_584 () Int) -(declare-fun x_282 () Int) -(declare-fun x_743 () Int) -(declare-fun x_56 () Int) -(declare-fun x_749 () Int) -(declare-fun x_411 () Int) -(declare-fun x_647 () Int) -(declare-fun x_219 () Int) -(declare-fun x_946 () Int) -(declare-fun x_433 () Int) -(declare-fun x_106 () Int) -(declare-fun x_38 () Int) -(declare-fun x_314 () Int) -(declare-fun x_481 () Int) -(declare-fun x_768 () Int) -(declare-fun x_579 () Int) -(declare-fun x_114 () Int) -(declare-fun x_894 () Int) -(declare-fun x_146 () Int) -(declare-fun x_577 () Int) -(declare-fun x_394 () Int) -(declare-fun x_566 () Int) -(declare-fun x_738 () Int) -(declare-fun x_506 () Int) -(declare-fun x_351 () Int) -(declare-fun x_493 () Int) -(declare-fun x_624 () Int) -(declare-fun x_653 () Int) -(declare-fun x_386 () Int) -(declare-fun x_526 () Int) -(declare-fun x_148 () Int) -(declare-fun x_131 () Int) -(declare-fun x_669 () Int) -(declare-fun x_982 () Int) -(declare-fun x_664 () Int) -(declare-fun x_501 () Int) -(declare-fun x_856 () Int) -(declare-fun x_828 () Int) -(declare-fun x_161 () Int) -(declare-fun x_772 () Int) -(declare-fun x_147 () Int) -(declare-fun x_967 () Int) -(declare-fun x_313 () Int) -(declare-fun x_681 () Int) -(declare-fun x_724 () Int) -(declare-fun x_636 () Int) -(declare-fun x_83 () Int) -(declare-fun x_754 () Int) -(declare-fun x_484 () Int) -(declare-fun x_49 () Int) -(declare-fun x_703 () Int) -(declare-fun x_36 () Int) -(declare-fun x_152 () Int) -(declare-fun x_187 () Int) -(declare-fun x_752 () Int) -(declare-fun x_191 () Int) -(declare-fun x_634 () Int) -(declare-fun x_788 () Int) -(declare-fun x_259 () Int) -(declare-fun x_431 () Int) -(declare-fun x_509 () Int) -(declare-fun x_93 () Int) -(declare-fun x_9 () Int) -(declare-fun x_513 () Int) -(declare-fun x_248 () Int) -(declare-fun x_272 () Int) -(declare-fun x_751 () Int) -(declare-fun x_686 () Int) -(declare-fun x_714 () Int) -(declare-fun x_807 () Int) -(declare-fun x_922 () Int) -(declare-fun x_81 () Int) -(declare-fun x_613 () Int) -(declare-fun x_928 () Int) -(declare-fun x_1604 () Int) -(declare-fun x_78 () Int) -(declare-fun x_249 () Int) -(declare-fun x_79 () Int) -(declare-fun x_649 () Int) -(declare-fun x_781 () Int) -(declare-fun x_687 () Int) -(declare-fun x_82 () Int) -(declare-fun x_804 () Int) -(declare-fun x_441 () Int) -(declare-fun x_651 () Int) -(declare-fun x_936 () Int) -(declare-fun x_1 () Int) -(declare-fun x_179 () Int) -(declare-fun x_199 () Int) -(declare-fun x_623 () Int) -(declare-fun x_794 () Int) -(declare-fun x_777 () Int) -(declare-fun x_214 () Int) -(declare-fun x_296 () Int) -(declare-fun x_949 () Int) -(declare-fun x_133 () Int) -(declare-fun x_829 () Int) -(declare-fun x_556 () Int) -(declare-fun x_617 () Int) -(declare-fun x_18 () Int) -(declare-fun x_728 () Int) -(declare-fun x_426 () Int) -(declare-fun x_898 () Int) -(declare-fun x_23 () Int) -(declare-fun x_843 () Int) -(declare-fun x_827 () Int) -(declare-fun x_831 () Int) -(declare-fun x_954 () Int) -(declare-fun x_341 () Int) -(declare-fun x_956 () Int) -(declare-fun x_983 () Int) -(declare-fun x_606 () Int) -(declare-fun x_874 () Int) -(declare-fun x_698 () Int) -(declare-fun x_782 () Int) -(declare-fun x_48 () Int) -(declare-fun x_172 () Int) -(declare-fun x_342 () Int) -(declare-fun x_238 () Int) -(declare-fun x_323 () Int) -(declare-fun x_608 () Int) -(declare-fun x_471 () Int) -(declare-fun x_216 () Int) -(declare-fun x_69 () Int) -(declare-fun x_438 () Int) -(declare-fun x_534 () Int) -(declare-fun x_368 () Int) -(declare-fun x_193 () Int) -(declare-fun x_532 () Int) -(declare-fun x_951 () Int) -(declare-fun x_258 () Int) -(declare-fun x_853 () Int) -(declare-fun x_132 () Int) -(declare-fun x_159 () Int) -(declare-fun x_217 () Int) -(declare-fun x_742 () Int) -(declare-fun x_311 () Int) -(declare-fun x_1403 () Int) -(declare-fun x_176 () Int) -(declare-fun x_254 () Int) -(declare-fun x_66 () Int) -(declare-fun x_144 () Int) -(declare-fun x_998 () Int) -(assert (<= 0 x_1)) -(assert (>= 1 x_1)) -(assert (<= 0 x_2)) -(assert (>= 1 x_2)) -(assert (<= 0 x_3)) -(assert (>= 1 x_3)) -(assert (<= 0 x_4)) -(assert (>= 1 x_4)) -(assert (<= 0 x_6)) -(assert (>= 1 x_6)) -(assert (<= 0 x_7)) -(assert (>= 1 x_7)) -(assert (<= 0 x_8)) -(assert (>= 1 x_8)) -(assert (<= 0 x_9)) -(assert (>= 1 x_9)) -(assert (<= 0 x_11)) -(assert (>= 1 x_11)) -(assert (<= 0 x_12)) -(assert (>= 1 x_12)) -(assert (<= 0 x_13)) -(assert (>= 1 x_13)) -(assert (<= 0 x_14)) -(assert (>= 1 x_14)) -(assert (<= 0 x_16)) -(assert (>= 1 x_16)) -(assert (<= 0 x_17)) -(assert (>= 1 x_17)) -(assert (<= 0 x_18)) -(assert (>= 1 x_18)) -(assert (<= 0 x_19)) -(assert (>= 1 x_19)) -(assert (<= 0 x_21)) -(assert (>= 1 x_21)) -(assert (<= 0 x_22)) -(assert (>= 1 x_22)) -(assert (<= 0 x_23)) -(assert (>= 1 x_23)) -(assert (<= 0 x_24)) -(assert (>= 1 x_24)) -(assert (<= 0 x_26)) -(assert (>= 1 x_26)) -(assert (<= 0 x_27)) -(assert (>= 1 x_27)) -(assert (<= 0 x_28)) -(assert (>= 1 x_28)) -(assert (<= 0 x_29)) -(assert (>= 1 x_29)) -(assert (<= 0 x_31)) -(assert (>= 1 x_31)) -(assert (<= 0 x_32)) -(assert (>= 1 x_32)) -(assert (<= 0 x_33)) -(assert (>= 1 x_33)) -(assert (<= 0 x_34)) -(assert (>= 1 x_34)) -(assert (<= 0 x_36)) -(assert (>= 1 x_36)) -(assert (<= 0 x_37)) -(assert (>= 1 x_37)) -(assert (<= 0 x_38)) -(assert (>= 1 x_38)) -(assert (<= 0 x_39)) -(assert (>= 1 x_39)) -(assert (<= 0 x_41)) -(assert (>= 1 x_41)) -(assert (<= 0 x_42)) -(assert (>= 1 x_42)) -(assert (<= 0 x_43)) -(assert (>= 1 x_43)) -(assert (<= 0 x_44)) -(assert (>= 1 x_44)) -(assert (<= 0 x_46)) -(assert (>= 1 x_46)) -(assert (<= 0 x_47)) -(assert (>= 1 x_47)) -(assert (<= 0 x_48)) -(assert (>= 1 x_48)) -(assert (<= 0 x_49)) -(assert (>= 1 x_49)) -(assert (<= 0 x_51)) -(assert (>= 1 x_51)) -(assert (<= 0 x_52)) -(assert (>= 1 x_52)) -(assert (<= 0 x_53)) -(assert (>= 1 x_53)) -(assert (<= 0 x_54)) -(assert (>= 1 x_54)) -(assert (<= 0 x_56)) -(assert (>= 1 x_56)) -(assert (<= 0 x_57)) -(assert (>= 1 x_57)) -(assert (<= 0 x_58)) -(assert (>= 1 x_58)) -(assert (<= 0 x_59)) -(assert (>= 1 x_59)) -(assert (<= 0 x_61)) -(assert (>= 1 x_61)) -(assert (<= 0 x_62)) -(assert (>= 1 x_62)) -(assert (<= 0 x_63)) -(assert (>= 1 x_63)) -(assert (<= 0 x_64)) -(assert (>= 1 x_64)) -(assert (<= 0 x_66)) -(assert (>= 1 x_66)) -(assert (<= 0 x_67)) -(assert (>= 1 x_67)) -(assert (<= 0 x_68)) -(assert (>= 1 x_68)) -(assert (<= 0 x_69)) -(assert (>= 1 x_69)) -(assert (<= 0 x_71)) -(assert (>= 1 x_71)) -(assert (<= 0 x_72)) -(assert (>= 1 x_72)) -(assert (<= 0 x_73)) -(assert (>= 1 x_73)) -(assert (<= 0 x_74)) -(assert (>= 1 x_74)) -(assert (<= 0 x_76)) -(assert (>= 1 x_76)) -(assert (<= 0 x_77)) -(assert (>= 1 x_77)) -(assert (<= 0 x_78)) -(assert (>= 1 x_78)) -(assert (<= 0 x_79)) -(assert (>= 1 x_79)) -(assert (<= 0 x_81)) -(assert (>= 1 x_81)) -(assert (<= 0 x_82)) -(assert (>= 1 x_82)) -(assert (<= 0 x_83)) -(assert (>= 1 x_83)) -(assert (<= 0 x_84)) -(assert (>= 1 x_84)) -(assert (<= 0 x_86)) -(assert (>= 1 x_86)) -(assert (<= 0 x_87)) -(assert (>= 1 x_87)) -(assert (<= 0 x_88)) -(assert (>= 1 x_88)) -(assert (<= 0 x_89)) -(assert (>= 1 x_89)) -(assert (<= 0 x_91)) -(assert (>= 1 x_91)) -(assert (<= 0 x_92)) -(assert (>= 1 x_92)) -(assert (<= 0 x_93)) -(assert (>= 1 x_93)) -(assert (<= 0 x_94)) -(assert (>= 1 x_94)) -(assert (<= 0 x_96)) -(assert (>= 1 x_96)) -(assert (<= 0 x_97)) -(assert (>= 1 x_97)) -(assert (<= 0 x_98)) -(assert (>= 1 x_98)) -(assert (<= 0 x_99)) -(assert (>= 1 x_99)) -(assert (<= 0 x_101)) -(assert (>= 1 x_101)) -(assert (<= 0 x_102)) -(assert (>= 1 x_102)) -(assert (<= 0 x_103)) -(assert (>= 1 x_103)) -(assert (<= 0 x_104)) -(assert (>= 1 x_104)) -(assert (<= 0 x_106)) -(assert (>= 1 x_106)) -(assert (<= 0 x_107)) -(assert (>= 1 x_107)) -(assert (<= 0 x_108)) -(assert (>= 1 x_108)) -(assert (<= 0 x_109)) -(assert (>= 1 x_109)) -(assert (<= 0 x_111)) -(assert (>= 1 x_111)) -(assert (<= 0 x_112)) -(assert (>= 1 x_112)) -(assert (<= 0 x_113)) -(assert (>= 1 x_113)) -(assert (<= 0 x_114)) -(assert (>= 1 x_114)) -(assert (<= 0 x_116)) -(assert (>= 1 x_116)) -(assert (<= 0 x_117)) -(assert (>= 1 x_117)) -(assert (<= 0 x_118)) -(assert (>= 1 x_118)) -(assert (<= 0 x_119)) -(assert (>= 1 x_119)) -(assert (<= 0 x_121)) -(assert (>= 1 x_121)) -(assert (<= 0 x_122)) -(assert (>= 1 x_122)) -(assert (<= 0 x_123)) -(assert (>= 1 x_123)) -(assert (<= 0 x_124)) -(assert (>= 1 x_124)) -(assert (<= 0 x_126)) -(assert (>= 1 x_126)) -(assert (<= 0 x_127)) -(assert (>= 1 x_127)) -(assert (<= 0 x_128)) -(assert (>= 1 x_128)) -(assert (<= 0 x_129)) -(assert (>= 1 x_129)) -(assert (<= 0 x_131)) -(assert (>= 1 x_131)) -(assert (<= 0 x_132)) -(assert (>= 1 x_132)) -(assert (<= 0 x_133)) -(assert (>= 1 x_133)) -(assert (<= 0 x_134)) -(assert (>= 1 x_134)) -(assert (<= 0 x_136)) -(assert (>= 1 x_136)) -(assert (<= 0 x_137)) -(assert (>= 1 x_137)) -(assert (<= 0 x_138)) -(assert (>= 1 x_138)) -(assert (<= 0 x_139)) -(assert (>= 1 x_139)) -(assert (<= 0 x_141)) -(assert (>= 1 x_141)) -(assert (<= 0 x_142)) -(assert (>= 1 x_142)) -(assert (<= 0 x_143)) -(assert (>= 1 x_143)) -(assert (<= 0 x_144)) -(assert (>= 1 x_144)) -(assert (<= 0 x_146)) -(assert (>= 1 x_146)) -(assert (<= 0 x_147)) -(assert (>= 1 x_147)) -(assert (<= 0 x_148)) -(assert (>= 1 x_148)) -(assert (<= 0 x_149)) -(assert (>= 1 x_149)) -(assert (<= 0 x_151)) -(assert (>= 1 x_151)) -(assert (<= 0 x_152)) -(assert (>= 1 x_152)) -(assert (<= 0 x_153)) -(assert (>= 1 x_153)) -(assert (<= 0 x_154)) -(assert (>= 1 x_154)) -(assert (<= 0 x_156)) -(assert (>= 1 x_156)) -(assert (<= 0 x_157)) -(assert (>= 1 x_157)) -(assert (<= 0 x_158)) -(assert (>= 1 x_158)) -(assert (<= 0 x_159)) -(assert (>= 1 x_159)) -(assert (<= 0 x_161)) -(assert (>= 1 x_161)) -(assert (<= 0 x_162)) -(assert (>= 1 x_162)) -(assert (<= 0 x_163)) -(assert (>= 1 x_163)) -(assert (<= 0 x_164)) -(assert (>= 1 x_164)) -(assert (<= 0 x_166)) -(assert (>= 1 x_166)) -(assert (<= 0 x_167)) -(assert (>= 1 x_167)) -(assert (<= 0 x_168)) -(assert (>= 1 x_168)) -(assert (<= 0 x_169)) -(assert (>= 1 x_169)) -(assert (<= 0 x_171)) -(assert (>= 1 x_171)) -(assert (<= 0 x_172)) -(assert (>= 1 x_172)) -(assert (<= 0 x_173)) -(assert (>= 1 x_173)) -(assert (<= 0 x_174)) -(assert (>= 1 x_174)) -(assert (<= 0 x_176)) -(assert (>= 1 x_176)) -(assert (<= 0 x_177)) -(assert (>= 1 x_177)) -(assert (<= 0 x_178)) -(assert (>= 1 x_178)) -(assert (<= 0 x_179)) -(assert (>= 1 x_179)) -(assert (<= 0 x_181)) -(assert (>= 1 x_181)) -(assert (<= 0 x_182)) -(assert (>= 1 x_182)) -(assert (<= 0 x_183)) -(assert (>= 1 x_183)) -(assert (<= 0 x_184)) -(assert (>= 1 x_184)) -(assert (<= 0 x_186)) -(assert (>= 1 x_186)) -(assert (<= 0 x_187)) -(assert (>= 1 x_187)) -(assert (<= 0 x_188)) -(assert (>= 1 x_188)) -(assert (<= 0 x_189)) -(assert (>= 1 x_189)) -(assert (<= 0 x_191)) -(assert (>= 1 x_191)) -(assert (<= 0 x_192)) -(assert (>= 1 x_192)) -(assert (<= 0 x_193)) -(assert (>= 1 x_193)) -(assert (<= 0 x_194)) -(assert (>= 1 x_194)) -(assert (<= 0 x_196)) -(assert (>= 1 x_196)) -(assert (<= 0 x_197)) -(assert (>= 1 x_197)) -(assert (<= 0 x_198)) -(assert (>= 1 x_198)) -(assert (<= 0 x_199)) -(assert (>= 1 x_199)) -(assert (<= 0 x_201)) -(assert (>= 1 x_201)) -(assert (<= 0 x_202)) -(assert (>= 1 x_202)) -(assert (<= 0 x_203)) -(assert (>= 1 x_203)) -(assert (<= 0 x_204)) -(assert (>= 1 x_204)) -(assert (<= 0 x_206)) -(assert (>= 1 x_206)) -(assert (<= 0 x_207)) -(assert (>= 1 x_207)) -(assert (<= 0 x_208)) -(assert (>= 1 x_208)) -(assert (<= 0 x_209)) -(assert (>= 1 x_209)) -(assert (<= 0 x_211)) -(assert (>= 1 x_211)) -(assert (<= 0 x_212)) -(assert (>= 1 x_212)) -(assert (<= 0 x_213)) -(assert (>= 1 x_213)) -(assert (<= 0 x_214)) -(assert (>= 1 x_214)) -(assert (<= 0 x_216)) -(assert (>= 1 x_216)) -(assert (<= 0 x_217)) -(assert (>= 1 x_217)) -(assert (<= 0 x_218)) -(assert (>= 1 x_218)) -(assert (<= 0 x_219)) -(assert (>= 1 x_219)) -(assert (<= 0 x_221)) -(assert (>= 1 x_221)) -(assert (<= 0 x_222)) -(assert (>= 1 x_222)) -(assert (<= 0 x_223)) -(assert (>= 1 x_223)) -(assert (<= 0 x_224)) -(assert (>= 1 x_224)) -(assert (<= 0 x_226)) -(assert (>= 1 x_226)) -(assert (<= 0 x_227)) -(assert (>= 1 x_227)) -(assert (<= 0 x_228)) -(assert (>= 1 x_228)) -(assert (<= 0 x_229)) -(assert (>= 1 x_229)) -(assert (<= 0 x_231)) -(assert (>= 1 x_231)) -(assert (<= 0 x_232)) -(assert (>= 1 x_232)) -(assert (<= 0 x_233)) -(assert (>= 1 x_233)) -(assert (<= 0 x_234)) -(assert (>= 1 x_234)) -(assert (<= 0 x_236)) -(assert (>= 1 x_236)) -(assert (<= 0 x_237)) -(assert (>= 1 x_237)) -(assert (<= 0 x_238)) -(assert (>= 1 x_238)) -(assert (<= 0 x_239)) -(assert (>= 1 x_239)) -(assert (<= 0 x_241)) -(assert (>= 1 x_241)) -(assert (<= 0 x_242)) -(assert (>= 1 x_242)) -(assert (<= 0 x_243)) -(assert (>= 1 x_243)) -(assert (<= 0 x_244)) -(assert (>= 1 x_244)) -(assert (<= 0 x_246)) -(assert (>= 1 x_246)) -(assert (<= 0 x_247)) -(assert (>= 1 x_247)) -(assert (<= 0 x_248)) -(assert (>= 1 x_248)) -(assert (<= 0 x_249)) -(assert (>= 1 x_249)) -(assert (<= 0 x_251)) -(assert (>= 1 x_251)) -(assert (<= 0 x_252)) -(assert (>= 1 x_252)) -(assert (<= 0 x_253)) -(assert (>= 1 x_253)) -(assert (<= 0 x_254)) -(assert (>= 1 x_254)) -(assert (<= 0 x_256)) -(assert (>= 1 x_256)) -(assert (<= 0 x_257)) -(assert (>= 1 x_257)) -(assert (<= 0 x_258)) -(assert (>= 1 x_258)) -(assert (<= 0 x_259)) -(assert (>= 1 x_259)) -(assert (<= 0 x_261)) -(assert (>= 1 x_261)) -(assert (<= 0 x_262)) -(assert (>= 1 x_262)) -(assert (<= 0 x_263)) -(assert (>= 1 x_263)) -(assert (<= 0 x_264)) -(assert (>= 1 x_264)) -(assert (<= 0 x_266)) -(assert (>= 1 x_266)) -(assert (<= 0 x_267)) -(assert (>= 1 x_267)) -(assert (<= 0 x_268)) -(assert (>= 1 x_268)) -(assert (<= 0 x_269)) -(assert (>= 1 x_269)) -(assert (<= 0 x_271)) -(assert (>= 1 x_271)) -(assert (<= 0 x_272)) -(assert (>= 1 x_272)) -(assert (<= 0 x_273)) -(assert (>= 1 x_273)) -(assert (<= 0 x_274)) -(assert (>= 1 x_274)) -(assert (<= 0 x_276)) -(assert (>= 1 x_276)) -(assert (<= 0 x_277)) -(assert (>= 1 x_277)) -(assert (<= 0 x_278)) -(assert (>= 1 x_278)) -(assert (<= 0 x_279)) -(assert (>= 1 x_279)) -(assert (<= 0 x_281)) -(assert (>= 1 x_281)) -(assert (<= 0 x_282)) -(assert (>= 1 x_282)) -(assert (<= 0 x_283)) -(assert (>= 1 x_283)) -(assert (<= 0 x_284)) -(assert (>= 1 x_284)) -(assert (<= 0 x_286)) -(assert (>= 1 x_286)) -(assert (<= 0 x_287)) -(assert (>= 1 x_287)) -(assert (<= 0 x_288)) -(assert (>= 1 x_288)) -(assert (<= 0 x_289)) -(assert (>= 1 x_289)) -(assert (<= 0 x_291)) -(assert (>= 1 x_291)) -(assert (<= 0 x_292)) -(assert (>= 1 x_292)) -(assert (<= 0 x_293)) -(assert (>= 1 x_293)) -(assert (<= 0 x_294)) -(assert (>= 1 x_294)) -(assert (<= 0 x_296)) -(assert (>= 1 x_296)) -(assert (<= 0 x_297)) -(assert (>= 1 x_297)) -(assert (<= 0 x_298)) -(assert (>= 1 x_298)) -(assert (<= 0 x_299)) -(assert (>= 1 x_299)) -(assert (<= 0 x_301)) -(assert (>= 1 x_301)) -(assert (<= 0 x_302)) -(assert (>= 1 x_302)) -(assert (<= 0 x_303)) -(assert (>= 1 x_303)) -(assert (<= 0 x_304)) -(assert (>= 1 x_304)) -(assert (<= 0 x_306)) -(assert (>= 1 x_306)) -(assert (<= 0 x_307)) -(assert (>= 1 x_307)) -(assert (<= 0 x_308)) -(assert (>= 1 x_308)) -(assert (<= 0 x_309)) -(assert (>= 1 x_309)) -(assert (<= 0 x_311)) -(assert (>= 1 x_311)) -(assert (<= 0 x_312)) -(assert (>= 1 x_312)) -(assert (<= 0 x_313)) -(assert (>= 1 x_313)) -(assert (<= 0 x_314)) -(assert (>= 1 x_314)) -(assert (<= 0 x_316)) -(assert (>= 1 x_316)) -(assert (<= 0 x_317)) -(assert (>= 1 x_317)) -(assert (<= 0 x_318)) -(assert (>= 1 x_318)) -(assert (<= 0 x_319)) -(assert (>= 1 x_319)) -(assert (<= 0 x_321)) -(assert (>= 1 x_321)) -(assert (<= 0 x_322)) -(assert (>= 1 x_322)) -(assert (<= 0 x_323)) -(assert (>= 1 x_323)) -(assert (<= 0 x_324)) -(assert (>= 1 x_324)) -(assert (<= 0 x_326)) -(assert (>= 1 x_326)) -(assert (<= 0 x_327)) -(assert (>= 1 x_327)) -(assert (<= 0 x_328)) -(assert (>= 1 x_328)) -(assert (<= 0 x_329)) -(assert (>= 1 x_329)) -(assert (<= 0 x_331)) -(assert (>= 1 x_331)) -(assert (<= 0 x_332)) -(assert (>= 1 x_332)) -(assert (<= 0 x_333)) -(assert (>= 1 x_333)) -(assert (<= 0 x_334)) -(assert (>= 1 x_334)) -(assert (<= 0 x_336)) -(assert (>= 1 x_336)) -(assert (<= 0 x_337)) -(assert (>= 1 x_337)) -(assert (<= 0 x_338)) -(assert (>= 1 x_338)) -(assert (<= 0 x_339)) -(assert (>= 1 x_339)) -(assert (<= 0 x_341)) -(assert (>= 1 x_341)) -(assert (<= 0 x_342)) -(assert (>= 1 x_342)) -(assert (<= 0 x_343)) -(assert (>= 1 x_343)) -(assert (<= 0 x_344)) -(assert (>= 1 x_344)) -(assert (<= 0 x_346)) -(assert (>= 1 x_346)) -(assert (<= 0 x_347)) -(assert (>= 1 x_347)) -(assert (<= 0 x_348)) -(assert (>= 1 x_348)) -(assert (<= 0 x_349)) -(assert (>= 1 x_349)) -(assert (<= 0 x_351)) -(assert (>= 1 x_351)) -(assert (<= 0 x_352)) -(assert (>= 1 x_352)) -(assert (<= 0 x_353)) -(assert (>= 1 x_353)) -(assert (<= 0 x_354)) -(assert (>= 1 x_354)) -(assert (<= 0 x_356)) -(assert (>= 1 x_356)) -(assert (<= 0 x_357)) -(assert (>= 1 x_357)) -(assert (<= 0 x_358)) -(assert (>= 1 x_358)) -(assert (<= 0 x_359)) -(assert (>= 1 x_359)) -(assert (<= 0 x_361)) -(assert (>= 1 x_361)) -(assert (<= 0 x_362)) -(assert (>= 1 x_362)) -(assert (<= 0 x_363)) -(assert (>= 1 x_363)) -(assert (<= 0 x_364)) -(assert (>= 1 x_364)) -(assert (<= 0 x_366)) -(assert (>= 1 x_366)) -(assert (<= 0 x_367)) -(assert (>= 1 x_367)) -(assert (<= 0 x_368)) -(assert (>= 1 x_368)) -(assert (<= 0 x_369)) -(assert (>= 1 x_369)) -(assert (<= 0 x_371)) -(assert (>= 1 x_371)) -(assert (<= 0 x_372)) -(assert (>= 1 x_372)) -(assert (<= 0 x_373)) -(assert (>= 1 x_373)) -(assert (<= 0 x_374)) -(assert (>= 1 x_374)) -(assert (<= 0 x_376)) -(assert (>= 1 x_376)) -(assert (<= 0 x_377)) -(assert (>= 1 x_377)) -(assert (<= 0 x_378)) -(assert (>= 1 x_378)) -(assert (<= 0 x_379)) -(assert (>= 1 x_379)) -(assert (<= 0 x_381)) -(assert (>= 1 x_381)) -(assert (<= 0 x_382)) -(assert (>= 1 x_382)) -(assert (<= 0 x_383)) -(assert (>= 1 x_383)) -(assert (<= 0 x_384)) -(assert (>= 1 x_384)) -(assert (<= 0 x_386)) -(assert (>= 1 x_386)) -(assert (<= 0 x_387)) -(assert (>= 1 x_387)) -(assert (<= 0 x_388)) -(assert (>= 1 x_388)) -(assert (<= 0 x_389)) -(assert (>= 1 x_389)) -(assert (<= 0 x_391)) -(assert (>= 1 x_391)) -(assert (<= 0 x_392)) -(assert (>= 1 x_392)) -(assert (<= 0 x_393)) -(assert (>= 1 x_393)) -(assert (<= 0 x_394)) -(assert (>= 1 x_394)) -(assert (<= 0 x_396)) -(assert (>= 1 x_396)) -(assert (<= 0 x_397)) -(assert (>= 1 x_397)) -(assert (<= 0 x_398)) -(assert (>= 1 x_398)) -(assert (<= 0 x_399)) -(assert (>= 1 x_399)) -(assert (<= 0 x_401)) -(assert (>= 1 x_401)) -(assert (<= 0 x_402)) -(assert (>= 1 x_402)) -(assert (<= 0 x_403)) -(assert (>= 1 x_403)) -(assert (<= 0 x_404)) -(assert (>= 1 x_404)) -(assert (<= 0 x_406)) -(assert (>= 1 x_406)) -(assert (<= 0 x_407)) -(assert (>= 1 x_407)) -(assert (<= 0 x_408)) -(assert (>= 1 x_408)) -(assert (<= 0 x_409)) -(assert (>= 1 x_409)) -(assert (<= 0 x_411)) -(assert (>= 1 x_411)) -(assert (<= 0 x_412)) -(assert (>= 1 x_412)) -(assert (<= 0 x_413)) -(assert (>= 1 x_413)) -(assert (<= 0 x_414)) -(assert (>= 1 x_414)) -(assert (<= 0 x_416)) -(assert (>= 1 x_416)) -(assert (<= 0 x_417)) -(assert (>= 1 x_417)) -(assert (<= 0 x_418)) -(assert (>= 1 x_418)) -(assert (<= 0 x_419)) -(assert (>= 1 x_419)) -(assert (<= 0 x_421)) -(assert (>= 1 x_421)) -(assert (<= 0 x_422)) -(assert (>= 1 x_422)) -(assert (<= 0 x_423)) -(assert (>= 1 x_423)) -(assert (<= 0 x_424)) -(assert (>= 1 x_424)) -(assert (<= 0 x_426)) -(assert (>= 1 x_426)) -(assert (<= 0 x_427)) -(assert (>= 1 x_427)) -(assert (<= 0 x_428)) -(assert (>= 1 x_428)) -(assert (<= 0 x_429)) -(assert (>= 1 x_429)) -(assert (<= 0 x_431)) -(assert (>= 1 x_431)) -(assert (<= 0 x_432)) -(assert (>= 1 x_432)) -(assert (<= 0 x_433)) -(assert (>= 1 x_433)) -(assert (<= 0 x_434)) -(assert (>= 1 x_434)) -(assert (<= 0 x_436)) -(assert (>= 1 x_436)) -(assert (<= 0 x_437)) -(assert (>= 1 x_437)) -(assert (<= 0 x_438)) -(assert (>= 1 x_438)) -(assert (<= 0 x_439)) -(assert (>= 1 x_439)) -(assert (<= 0 x_441)) -(assert (>= 1 x_441)) -(assert (<= 0 x_442)) -(assert (>= 1 x_442)) -(assert (<= 0 x_443)) -(assert (>= 1 x_443)) -(assert (<= 0 x_444)) -(assert (>= 1 x_444)) -(assert (<= 0 x_446)) -(assert (>= 1 x_446)) -(assert (<= 0 x_447)) -(assert (>= 1 x_447)) -(assert (<= 0 x_448)) -(assert (>= 1 x_448)) -(assert (<= 0 x_449)) -(assert (>= 1 x_449)) -(assert (<= 0 x_451)) -(assert (>= 1 x_451)) -(assert (<= 0 x_452)) -(assert (>= 1 x_452)) -(assert (<= 0 x_453)) -(assert (>= 1 x_453)) -(assert (<= 0 x_454)) -(assert (>= 1 x_454)) -(assert (<= 0 x_456)) -(assert (>= 1 x_456)) -(assert (<= 0 x_457)) -(assert (>= 1 x_457)) -(assert (<= 0 x_458)) -(assert (>= 1 x_458)) -(assert (<= 0 x_459)) -(assert (>= 1 x_459)) -(assert (<= 0 x_461)) -(assert (>= 1 x_461)) -(assert (<= 0 x_462)) -(assert (>= 1 x_462)) -(assert (<= 0 x_463)) -(assert (>= 1 x_463)) -(assert (<= 0 x_464)) -(assert (>= 1 x_464)) -(assert (<= 0 x_466)) -(assert (>= 1 x_466)) -(assert (<= 0 x_467)) -(assert (>= 1 x_467)) -(assert (<= 0 x_468)) -(assert (>= 1 x_468)) -(assert (<= 0 x_469)) -(assert (>= 1 x_469)) -(assert (<= 0 x_471)) -(assert (>= 1 x_471)) -(assert (<= 0 x_472)) -(assert (>= 1 x_472)) -(assert (<= 0 x_473)) -(assert (>= 1 x_473)) -(assert (<= 0 x_474)) -(assert (>= 1 x_474)) -(assert (<= 0 x_476)) -(assert (>= 1 x_476)) -(assert (<= 0 x_477)) -(assert (>= 1 x_477)) -(assert (<= 0 x_478)) -(assert (>= 1 x_478)) -(assert (<= 0 x_479)) -(assert (>= 1 x_479)) -(assert (<= 0 x_481)) -(assert (>= 1 x_481)) -(assert (<= 0 x_482)) -(assert (>= 1 x_482)) -(assert (<= 0 x_483)) -(assert (>= 1 x_483)) -(assert (<= 0 x_484)) -(assert (>= 1 x_484)) -(assert (<= 0 x_486)) -(assert (>= 1 x_486)) -(assert (<= 0 x_487)) -(assert (>= 1 x_487)) -(assert (<= 0 x_488)) -(assert (>= 1 x_488)) -(assert (<= 0 x_489)) -(assert (>= 1 x_489)) -(assert (<= 0 x_491)) -(assert (>= 1 x_491)) -(assert (<= 0 x_492)) -(assert (>= 1 x_492)) -(assert (<= 0 x_493)) -(assert (>= 1 x_493)) -(assert (<= 0 x_494)) -(assert (>= 1 x_494)) -(assert (<= 0 x_496)) -(assert (>= 1 x_496)) -(assert (<= 0 x_497)) -(assert (>= 1 x_497)) -(assert (<= 0 x_498)) -(assert (>= 1 x_498)) -(assert (<= 0 x_499)) -(assert (>= 1 x_499)) -(assert (<= 0 x_501)) -(assert (>= 1 x_501)) -(assert (<= 0 x_502)) -(assert (>= 1 x_502)) -(assert (<= 0 x_503)) -(assert (>= 1 x_503)) -(assert (<= 0 x_504)) -(assert (>= 1 x_504)) -(assert (<= 0 x_506)) -(assert (>= 1 x_506)) -(assert (<= 0 x_507)) -(assert (>= 1 x_507)) -(assert (<= 0 x_508)) -(assert (>= 1 x_508)) -(assert (<= 0 x_509)) -(assert (>= 1 x_509)) -(assert (<= 0 x_511)) -(assert (>= 1 x_511)) -(assert (<= 0 x_512)) -(assert (>= 1 x_512)) -(assert (<= 0 x_513)) -(assert (>= 1 x_513)) -(assert (<= 0 x_514)) -(assert (>= 1 x_514)) -(assert (<= 0 x_516)) -(assert (>= 1 x_516)) -(assert (<= 0 x_517)) -(assert (>= 1 x_517)) -(assert (<= 0 x_518)) -(assert (>= 1 x_518)) -(assert (<= 0 x_519)) -(assert (>= 1 x_519)) -(assert (<= 0 x_521)) -(assert (>= 1 x_521)) -(assert (<= 0 x_522)) -(assert (>= 1 x_522)) -(assert (<= 0 x_523)) -(assert (>= 1 x_523)) -(assert (<= 0 x_524)) -(assert (>= 1 x_524)) -(assert (<= 0 x_526)) -(assert (>= 1 x_526)) -(assert (<= 0 x_527)) -(assert (>= 1 x_527)) -(assert (<= 0 x_528)) -(assert (>= 1 x_528)) -(assert (<= 0 x_529)) -(assert (>= 1 x_529)) -(assert (<= 0 x_531)) -(assert (>= 1 x_531)) -(assert (<= 0 x_532)) -(assert (>= 1 x_532)) -(assert (<= 0 x_533)) -(assert (>= 1 x_533)) -(assert (<= 0 x_534)) -(assert (>= 1 x_534)) -(assert (<= 0 x_536)) -(assert (>= 1 x_536)) -(assert (<= 0 x_537)) -(assert (>= 1 x_537)) -(assert (<= 0 x_538)) -(assert (>= 1 x_538)) -(assert (<= 0 x_539)) -(assert (>= 1 x_539)) -(assert (<= 0 x_541)) -(assert (>= 1 x_541)) -(assert (<= 0 x_542)) -(assert (>= 1 x_542)) -(assert (<= 0 x_543)) -(assert (>= 1 x_543)) -(assert (<= 0 x_544)) -(assert (>= 1 x_544)) -(assert (<= 0 x_546)) -(assert (>= 1 x_546)) -(assert (<= 0 x_547)) -(assert (>= 1 x_547)) -(assert (<= 0 x_548)) -(assert (>= 1 x_548)) -(assert (<= 0 x_549)) -(assert (>= 1 x_549)) -(assert (<= 0 x_551)) -(assert (>= 1 x_551)) -(assert (<= 0 x_552)) -(assert (>= 1 x_552)) -(assert (<= 0 x_553)) -(assert (>= 1 x_553)) -(assert (<= 0 x_554)) -(assert (>= 1 x_554)) -(assert (<= 0 x_556)) -(assert (>= 1 x_556)) -(assert (<= 0 x_557)) -(assert (>= 1 x_557)) -(assert (<= 0 x_558)) -(assert (>= 1 x_558)) -(assert (<= 0 x_559)) -(assert (>= 1 x_559)) -(assert (<= 0 x_561)) -(assert (>= 1 x_561)) -(assert (<= 0 x_562)) -(assert (>= 1 x_562)) -(assert (<= 0 x_563)) -(assert (>= 1 x_563)) -(assert (<= 0 x_564)) -(assert (>= 1 x_564)) -(assert (<= 0 x_566)) -(assert (>= 1 x_566)) -(assert (<= 0 x_567)) -(assert (>= 1 x_567)) -(assert (<= 0 x_568)) -(assert (>= 1 x_568)) -(assert (<= 0 x_569)) -(assert (>= 1 x_569)) -(assert (<= 0 x_571)) -(assert (>= 1 x_571)) -(assert (<= 0 x_572)) -(assert (>= 1 x_572)) -(assert (<= 0 x_573)) -(assert (>= 1 x_573)) -(assert (<= 0 x_574)) -(assert (>= 1 x_574)) -(assert (<= 0 x_576)) -(assert (>= 1 x_576)) -(assert (<= 0 x_577)) -(assert (>= 1 x_577)) -(assert (<= 0 x_578)) -(assert (>= 1 x_578)) -(assert (<= 0 x_579)) -(assert (>= 1 x_579)) -(assert (<= 0 x_581)) -(assert (>= 1 x_581)) -(assert (<= 0 x_582)) -(assert (>= 1 x_582)) -(assert (<= 0 x_583)) -(assert (>= 1 x_583)) -(assert (<= 0 x_584)) -(assert (>= 1 x_584)) -(assert (<= 0 x_586)) -(assert (>= 1 x_586)) -(assert (<= 0 x_587)) -(assert (>= 1 x_587)) -(assert (<= 0 x_588)) -(assert (>= 1 x_588)) -(assert (<= 0 x_589)) -(assert (>= 1 x_589)) -(assert (<= 0 x_591)) -(assert (>= 1 x_591)) -(assert (<= 0 x_592)) -(assert (>= 1 x_592)) -(assert (<= 0 x_593)) -(assert (>= 1 x_593)) -(assert (<= 0 x_594)) -(assert (>= 1 x_594)) -(assert (<= 0 x_596)) -(assert (>= 1 x_596)) -(assert (<= 0 x_597)) -(assert (>= 1 x_597)) -(assert (<= 0 x_598)) -(assert (>= 1 x_598)) -(assert (<= 0 x_599)) -(assert (>= 1 x_599)) -(assert (<= 0 x_601)) -(assert (>= 1 x_601)) -(assert (<= 0 x_602)) -(assert (>= 1 x_602)) -(assert (<= 0 x_603)) -(assert (>= 1 x_603)) -(assert (<= 0 x_604)) -(assert (>= 1 x_604)) -(assert (<= 0 x_606)) -(assert (>= 1 x_606)) -(assert (<= 0 x_607)) -(assert (>= 1 x_607)) -(assert (<= 0 x_608)) -(assert (>= 1 x_608)) -(assert (<= 0 x_609)) -(assert (>= 1 x_609)) -(assert (<= 0 x_611)) -(assert (>= 1 x_611)) -(assert (<= 0 x_612)) -(assert (>= 1 x_612)) -(assert (<= 0 x_613)) -(assert (>= 1 x_613)) -(assert (<= 0 x_614)) -(assert (>= 1 x_614)) -(assert (<= 0 x_616)) -(assert (>= 1 x_616)) -(assert (<= 0 x_617)) -(assert (>= 1 x_617)) -(assert (<= 0 x_618)) -(assert (>= 1 x_618)) -(assert (<= 0 x_619)) -(assert (>= 1 x_619)) -(assert (<= 0 x_621)) -(assert (>= 1 x_621)) -(assert (<= 0 x_622)) -(assert (>= 1 x_622)) -(assert (<= 0 x_623)) -(assert (>= 1 x_623)) -(assert (<= 0 x_624)) -(assert (>= 1 x_624)) -(assert (<= 0 x_626)) -(assert (>= 1 x_626)) -(assert (<= 0 x_627)) -(assert (>= 1 x_627)) -(assert (<= 0 x_628)) -(assert (>= 1 x_628)) -(assert (<= 0 x_629)) -(assert (>= 1 x_629)) -(assert (<= 0 x_631)) -(assert (>= 1 x_631)) -(assert (<= 0 x_632)) -(assert (>= 1 x_632)) -(assert (<= 0 x_633)) -(assert (>= 1 x_633)) -(assert (<= 0 x_634)) -(assert (>= 1 x_634)) -(assert (<= 0 x_636)) -(assert (>= 1 x_636)) -(assert (<= 0 x_637)) -(assert (>= 1 x_637)) -(assert (<= 0 x_638)) -(assert (>= 1 x_638)) -(assert (<= 0 x_639)) -(assert (>= 1 x_639)) -(assert (<= 0 x_641)) -(assert (>= 1 x_641)) -(assert (<= 0 x_642)) -(assert (>= 1 x_642)) -(assert (<= 0 x_643)) -(assert (>= 1 x_643)) -(assert (<= 0 x_644)) -(assert (>= 1 x_644)) -(assert (<= 0 x_646)) -(assert (>= 1 x_646)) -(assert (<= 0 x_647)) -(assert (>= 1 x_647)) -(assert (<= 0 x_648)) -(assert (>= 1 x_648)) -(assert (<= 0 x_649)) -(assert (>= 1 x_649)) -(assert (<= 0 x_651)) -(assert (>= 1 x_651)) -(assert (<= 0 x_652)) -(assert (>= 1 x_652)) -(assert (<= 0 x_653)) -(assert (>= 1 x_653)) -(assert (<= 0 x_654)) -(assert (>= 1 x_654)) -(assert (<= 0 x_656)) -(assert (>= 1 x_656)) -(assert (<= 0 x_657)) -(assert (>= 1 x_657)) -(assert (<= 0 x_658)) -(assert (>= 1 x_658)) -(assert (<= 0 x_659)) -(assert (>= 1 x_659)) -(assert (<= 0 x_661)) -(assert (>= 1 x_661)) -(assert (<= 0 x_662)) -(assert (>= 1 x_662)) -(assert (<= 0 x_663)) -(assert (>= 1 x_663)) -(assert (<= 0 x_664)) -(assert (>= 1 x_664)) -(assert (<= 0 x_666)) -(assert (>= 1 x_666)) -(assert (<= 0 x_667)) -(assert (>= 1 x_667)) -(assert (<= 0 x_668)) -(assert (>= 1 x_668)) -(assert (<= 0 x_669)) -(assert (>= 1 x_669)) -(assert (<= 0 x_671)) -(assert (>= 1 x_671)) -(assert (<= 0 x_672)) -(assert (>= 1 x_672)) -(assert (<= 0 x_673)) -(assert (>= 1 x_673)) -(assert (<= 0 x_674)) -(assert (>= 1 x_674)) -(assert (<= 0 x_676)) -(assert (>= 1 x_676)) -(assert (<= 0 x_677)) -(assert (>= 1 x_677)) -(assert (<= 0 x_678)) -(assert (>= 1 x_678)) -(assert (<= 0 x_679)) -(assert (>= 1 x_679)) -(assert (<= 0 x_681)) -(assert (>= 1 x_681)) -(assert (<= 0 x_682)) -(assert (>= 1 x_682)) -(assert (<= 0 x_683)) -(assert (>= 1 x_683)) -(assert (<= 0 x_684)) -(assert (>= 1 x_684)) -(assert (<= 0 x_686)) -(assert (>= 1 x_686)) -(assert (<= 0 x_687)) -(assert (>= 1 x_687)) -(assert (<= 0 x_688)) -(assert (>= 1 x_688)) -(assert (<= 0 x_689)) -(assert (>= 1 x_689)) -(assert (<= 0 x_691)) -(assert (>= 1 x_691)) -(assert (<= 0 x_692)) -(assert (>= 1 x_692)) -(assert (<= 0 x_693)) -(assert (>= 1 x_693)) -(assert (<= 0 x_694)) -(assert (>= 1 x_694)) -(assert (<= 0 x_696)) -(assert (>= 1 x_696)) -(assert (<= 0 x_697)) -(assert (>= 1 x_697)) -(assert (<= 0 x_698)) -(assert (>= 1 x_698)) -(assert (<= 0 x_699)) -(assert (>= 1 x_699)) -(assert (<= 0 x_701)) -(assert (>= 1 x_701)) -(assert (<= 0 x_702)) -(assert (>= 1 x_702)) -(assert (<= 0 x_703)) -(assert (>= 1 x_703)) -(assert (<= 0 x_704)) -(assert (>= 1 x_704)) -(assert (<= 0 x_706)) -(assert (>= 1 x_706)) -(assert (<= 0 x_707)) -(assert (>= 1 x_707)) -(assert (<= 0 x_708)) -(assert (>= 1 x_708)) -(assert (<= 0 x_709)) -(assert (>= 1 x_709)) -(assert (<= 0 x_711)) -(assert (>= 1 x_711)) -(assert (<= 0 x_712)) -(assert (>= 1 x_712)) -(assert (<= 0 x_713)) -(assert (>= 1 x_713)) -(assert (<= 0 x_714)) -(assert (>= 1 x_714)) -(assert (<= 0 x_716)) -(assert (>= 1 x_716)) -(assert (<= 0 x_717)) -(assert (>= 1 x_717)) -(assert (<= 0 x_718)) -(assert (>= 1 x_718)) -(assert (<= 0 x_719)) -(assert (>= 1 x_719)) -(assert (<= 0 x_721)) -(assert (>= 1 x_721)) -(assert (<= 0 x_722)) -(assert (>= 1 x_722)) -(assert (<= 0 x_723)) -(assert (>= 1 x_723)) -(assert (<= 0 x_724)) -(assert (>= 1 x_724)) -(assert (<= 0 x_726)) -(assert (>= 1 x_726)) -(assert (<= 0 x_727)) -(assert (>= 1 x_727)) -(assert (<= 0 x_728)) -(assert (>= 1 x_728)) -(assert (<= 0 x_729)) -(assert (>= 1 x_729)) -(assert (<= 0 x_731)) -(assert (>= 1 x_731)) -(assert (<= 0 x_732)) -(assert (>= 1 x_732)) -(assert (<= 0 x_733)) -(assert (>= 1 x_733)) -(assert (<= 0 x_734)) -(assert (>= 1 x_734)) -(assert (<= 0 x_736)) -(assert (>= 1 x_736)) -(assert (<= 0 x_737)) -(assert (>= 1 x_737)) -(assert (<= 0 x_738)) -(assert (>= 1 x_738)) -(assert (<= 0 x_739)) -(assert (>= 1 x_739)) -(assert (<= 0 x_741)) -(assert (>= 1 x_741)) -(assert (<= 0 x_742)) -(assert (>= 1 x_742)) -(assert (<= 0 x_743)) -(assert (>= 1 x_743)) -(assert (<= 0 x_744)) -(assert (>= 1 x_744)) -(assert (<= 0 x_746)) -(assert (>= 1 x_746)) -(assert (<= 0 x_747)) -(assert (>= 1 x_747)) -(assert (<= 0 x_748)) -(assert (>= 1 x_748)) -(assert (<= 0 x_749)) -(assert (>= 1 x_749)) -(assert (<= 0 x_751)) -(assert (>= 1 x_751)) -(assert (<= 0 x_752)) -(assert (>= 1 x_752)) -(assert (<= 0 x_753)) -(assert (>= 1 x_753)) -(assert (<= 0 x_754)) -(assert (>= 1 x_754)) -(assert (<= 0 x_756)) -(assert (>= 1 x_756)) -(assert (<= 0 x_757)) -(assert (>= 1 x_757)) -(assert (<= 0 x_758)) -(assert (>= 1 x_758)) -(assert (<= 0 x_759)) -(assert (>= 1 x_759)) -(assert (<= 0 x_761)) -(assert (>= 1 x_761)) -(assert (<= 0 x_762)) -(assert (>= 1 x_762)) -(assert (<= 0 x_763)) -(assert (>= 1 x_763)) -(assert (<= 0 x_764)) -(assert (>= 1 x_764)) -(assert (<= 0 x_766)) -(assert (>= 1 x_766)) -(assert (<= 0 x_767)) -(assert (>= 1 x_767)) -(assert (<= 0 x_768)) -(assert (>= 1 x_768)) -(assert (<= 0 x_769)) -(assert (>= 1 x_769)) -(assert (<= 0 x_771)) -(assert (>= 1 x_771)) -(assert (<= 0 x_772)) -(assert (>= 1 x_772)) -(assert (<= 0 x_773)) -(assert (>= 1 x_773)) -(assert (<= 0 x_774)) -(assert (>= 1 x_774)) -(assert (<= 0 x_776)) -(assert (>= 1 x_776)) -(assert (<= 0 x_777)) -(assert (>= 1 x_777)) -(assert (<= 0 x_778)) -(assert (>= 1 x_778)) -(assert (<= 0 x_779)) -(assert (>= 1 x_779)) -(assert (<= 0 x_781)) -(assert (>= 1 x_781)) -(assert (<= 0 x_782)) -(assert (>= 1 x_782)) -(assert (<= 0 x_783)) -(assert (>= 1 x_783)) -(assert (<= 0 x_784)) -(assert (>= 1 x_784)) -(assert (<= 0 x_786)) -(assert (>= 1 x_786)) -(assert (<= 0 x_787)) -(assert (>= 1 x_787)) -(assert (<= 0 x_788)) -(assert (>= 1 x_788)) -(assert (<= 0 x_789)) -(assert (>= 1 x_789)) -(assert (<= 0 x_791)) -(assert (>= 1 x_791)) -(assert (<= 0 x_792)) -(assert (>= 1 x_792)) -(assert (<= 0 x_793)) -(assert (>= 1 x_793)) -(assert (<= 0 x_794)) -(assert (>= 1 x_794)) -(assert (<= 0 x_796)) -(assert (>= 1 x_796)) -(assert (<= 0 x_797)) -(assert (>= 1 x_797)) -(assert (<= 0 x_798)) -(assert (>= 1 x_798)) -(assert (<= 0 x_799)) -(assert (>= 1 x_799)) -(assert (<= 0 x_801)) -(assert (>= 1 x_801)) -(assert (<= 0 x_802)) -(assert (>= 1 x_802)) -(assert (<= 0 x_803)) -(assert (>= 1 x_803)) -(assert (<= 0 x_804)) -(assert (>= 1 x_804)) -(assert (<= 0 x_806)) -(assert (>= 1 x_806)) -(assert (<= 0 x_807)) -(assert (>= 1 x_807)) -(assert (<= 0 x_808)) -(assert (>= 1 x_808)) -(assert (<= 0 x_809)) -(assert (>= 1 x_809)) -(assert (<= 0 x_811)) -(assert (>= 1 x_811)) -(assert (<= 0 x_812)) -(assert (>= 1 x_812)) -(assert (<= 0 x_813)) -(assert (>= 1 x_813)) -(assert (<= 0 x_814)) -(assert (>= 1 x_814)) -(assert (<= 0 x_816)) -(assert (>= 1 x_816)) -(assert (<= 0 x_817)) -(assert (>= 1 x_817)) -(assert (<= 0 x_818)) -(assert (>= 1 x_818)) -(assert (<= 0 x_819)) -(assert (>= 1 x_819)) -(assert (<= 0 x_821)) -(assert (>= 1 x_821)) -(assert (<= 0 x_822)) -(assert (>= 1 x_822)) -(assert (<= 0 x_823)) -(assert (>= 1 x_823)) -(assert (<= 0 x_824)) -(assert (>= 1 x_824)) -(assert (<= 0 x_826)) -(assert (>= 1 x_826)) -(assert (<= 0 x_827)) -(assert (>= 1 x_827)) -(assert (<= 0 x_828)) -(assert (>= 1 x_828)) -(assert (<= 0 x_829)) -(assert (>= 1 x_829)) -(assert (<= 0 x_831)) -(assert (>= 1 x_831)) -(assert (<= 0 x_832)) -(assert (>= 1 x_832)) -(assert (<= 0 x_833)) -(assert (>= 1 x_833)) -(assert (<= 0 x_834)) -(assert (>= 1 x_834)) -(assert (<= 0 x_836)) -(assert (>= 1 x_836)) -(assert (<= 0 x_837)) -(assert (>= 1 x_837)) -(assert (<= 0 x_838)) -(assert (>= 1 x_838)) -(assert (<= 0 x_839)) -(assert (>= 1 x_839)) -(assert (<= 0 x_841)) -(assert (>= 1 x_841)) -(assert (<= 0 x_842)) -(assert (>= 1 x_842)) -(assert (<= 0 x_843)) -(assert (>= 1 x_843)) -(assert (<= 0 x_844)) -(assert (>= 1 x_844)) -(assert (<= 0 x_846)) -(assert (>= 1 x_846)) -(assert (<= 0 x_847)) -(assert (>= 1 x_847)) -(assert (<= 0 x_848)) -(assert (>= 1 x_848)) -(assert (<= 0 x_849)) -(assert (>= 1 x_849)) -(assert (<= 0 x_851)) -(assert (>= 1 x_851)) -(assert (<= 0 x_852)) -(assert (>= 1 x_852)) -(assert (<= 0 x_853)) -(assert (>= 1 x_853)) -(assert (<= 0 x_854)) -(assert (>= 1 x_854)) -(assert (<= 0 x_856)) -(assert (>= 1 x_856)) -(assert (<= 0 x_857)) -(assert (>= 1 x_857)) -(assert (<= 0 x_858)) -(assert (>= 1 x_858)) -(assert (<= 0 x_859)) -(assert (>= 1 x_859)) -(assert (<= 0 x_861)) -(assert (>= 1 x_861)) -(assert (<= 0 x_862)) -(assert (>= 1 x_862)) -(assert (<= 0 x_863)) -(assert (>= 1 x_863)) -(assert (<= 0 x_864)) -(assert (>= 1 x_864)) -(assert (<= 0 x_866)) -(assert (>= 1 x_866)) -(assert (<= 0 x_867)) -(assert (>= 1 x_867)) -(assert (<= 0 x_868)) -(assert (>= 1 x_868)) -(assert (<= 0 x_869)) -(assert (>= 1 x_869)) -(assert (<= 0 x_871)) -(assert (>= 1 x_871)) -(assert (<= 0 x_872)) -(assert (>= 1 x_872)) -(assert (<= 0 x_873)) -(assert (>= 1 x_873)) -(assert (<= 0 x_874)) -(assert (>= 1 x_874)) -(assert (<= 0 x_876)) -(assert (>= 1 x_876)) -(assert (<= 0 x_877)) -(assert (>= 1 x_877)) -(assert (<= 0 x_878)) -(assert (>= 1 x_878)) -(assert (<= 0 x_879)) -(assert (>= 1 x_879)) -(assert (<= 0 x_881)) -(assert (>= 1 x_881)) -(assert (<= 0 x_882)) -(assert (>= 1 x_882)) -(assert (<= 0 x_883)) -(assert (>= 1 x_883)) -(assert (<= 0 x_884)) -(assert (>= 1 x_884)) -(assert (<= 0 x_886)) -(assert (>= 1 x_886)) -(assert (<= 0 x_887)) -(assert (>= 1 x_887)) -(assert (<= 0 x_888)) -(assert (>= 1 x_888)) -(assert (<= 0 x_889)) -(assert (>= 1 x_889)) -(assert (<= 0 x_891)) -(assert (>= 1 x_891)) -(assert (<= 0 x_892)) -(assert (>= 1 x_892)) -(assert (<= 0 x_893)) -(assert (>= 1 x_893)) -(assert (<= 0 x_894)) -(assert (>= 1 x_894)) -(assert (<= 0 x_896)) -(assert (>= 1 x_896)) -(assert (<= 0 x_897)) -(assert (>= 1 x_897)) -(assert (<= 0 x_898)) -(assert (>= 1 x_898)) -(assert (<= 0 x_899)) -(assert (>= 1 x_899)) -(assert (<= 0 x_901)) -(assert (>= 1 x_901)) -(assert (<= 0 x_902)) -(assert (>= 1 x_902)) -(assert (<= 0 x_903)) -(assert (>= 1 x_903)) -(assert (<= 0 x_904)) -(assert (>= 1 x_904)) -(assert (<= 0 x_906)) -(assert (>= 1 x_906)) -(assert (<= 0 x_907)) -(assert (>= 1 x_907)) -(assert (<= 0 x_908)) -(assert (>= 1 x_908)) -(assert (<= 0 x_909)) -(assert (>= 1 x_909)) -(assert (<= 0 x_911)) -(assert (>= 1 x_911)) -(assert (<= 0 x_912)) -(assert (>= 1 x_912)) -(assert (<= 0 x_913)) -(assert (>= 1 x_913)) -(assert (<= 0 x_914)) -(assert (>= 1 x_914)) -(assert (<= 0 x_916)) -(assert (>= 1 x_916)) -(assert (<= 0 x_917)) -(assert (>= 1 x_917)) -(assert (<= 0 x_918)) -(assert (>= 1 x_918)) -(assert (<= 0 x_919)) -(assert (>= 1 x_919)) -(assert (<= 0 x_921)) -(assert (>= 1 x_921)) -(assert (<= 0 x_922)) -(assert (>= 1 x_922)) -(assert (<= 0 x_923)) -(assert (>= 1 x_923)) -(assert (<= 0 x_924)) -(assert (>= 1 x_924)) -(assert (<= 0 x_926)) -(assert (>= 1 x_926)) -(assert (<= 0 x_927)) -(assert (>= 1 x_927)) -(assert (<= 0 x_928)) -(assert (>= 1 x_928)) -(assert (<= 0 x_929)) -(assert (>= 1 x_929)) -(assert (<= 0 x_931)) -(assert (>= 1 x_931)) -(assert (<= 0 x_932)) -(assert (>= 1 x_932)) -(assert (<= 0 x_933)) -(assert (>= 1 x_933)) -(assert (<= 0 x_934)) -(assert (>= 1 x_934)) -(assert (<= 0 x_936)) -(assert (>= 1 x_936)) -(assert (<= 0 x_937)) -(assert (>= 1 x_937)) -(assert (<= 0 x_938)) -(assert (>= 1 x_938)) -(assert (<= 0 x_939)) -(assert (>= 1 x_939)) -(assert (<= 0 x_941)) -(assert (>= 1 x_941)) -(assert (<= 0 x_942)) -(assert (>= 1 x_942)) -(assert (<= 0 x_943)) -(assert (>= 1 x_943)) -(assert (<= 0 x_944)) -(assert (>= 1 x_944)) -(assert (<= 0 x_946)) -(assert (>= 1 x_946)) -(assert (<= 0 x_947)) -(assert (>= 1 x_947)) -(assert (<= 0 x_948)) -(assert (>= 1 x_948)) -(assert (<= 0 x_949)) -(assert (>= 1 x_949)) -(assert (<= 0 x_951)) -(assert (>= 1 x_951)) -(assert (<= 0 x_952)) -(assert (>= 1 x_952)) -(assert (<= 0 x_953)) -(assert (>= 1 x_953)) -(assert (<= 0 x_954)) -(assert (>= 1 x_954)) -(assert (<= 0 x_956)) -(assert (>= 1 x_956)) -(assert (<= 0 x_957)) -(assert (>= 1 x_957)) -(assert (<= 0 x_958)) -(assert (>= 1 x_958)) -(assert (<= 0 x_959)) -(assert (>= 1 x_959)) -(assert (<= 0 x_961)) -(assert (>= 1 x_961)) -(assert (<= 0 x_962)) -(assert (>= 1 x_962)) -(assert (<= 0 x_963)) -(assert (>= 1 x_963)) -(assert (<= 0 x_964)) -(assert (>= 1 x_964)) -(assert (<= 0 x_966)) -(assert (>= 1 x_966)) -(assert (<= 0 x_967)) -(assert (>= 1 x_967)) -(assert (<= 0 x_968)) -(assert (>= 1 x_968)) -(assert (<= 0 x_969)) -(assert (>= 1 x_969)) -(assert (<= 0 x_971)) -(assert (>= 1 x_971)) -(assert (<= 0 x_972)) -(assert (>= 1 x_972)) -(assert (<= 0 x_973)) -(assert (>= 1 x_973)) -(assert (<= 0 x_974)) -(assert (>= 1 x_974)) -(assert (<= 0 x_976)) -(assert (>= 1 x_976)) -(assert (<= 0 x_977)) -(assert (>= 1 x_977)) -(assert (<= 0 x_978)) -(assert (>= 1 x_978)) -(assert (<= 0 x_979)) -(assert (>= 1 x_979)) -(assert (<= 0 x_981)) -(assert (>= 1 x_981)) -(assert (<= 0 x_982)) -(assert (>= 1 x_982)) -(assert (<= 0 x_983)) -(assert (>= 1 x_983)) -(assert (<= 0 x_984)) -(assert (>= 1 x_984)) -(assert (<= 0 x_986)) -(assert (>= 1 x_986)) -(assert (<= 0 x_987)) -(assert (>= 1 x_987)) -(assert (<= 0 x_988)) -(assert (>= 1 x_988)) -(assert (<= 0 x_989)) -(assert (>= 1 x_989)) -(assert (<= 0 x_991)) -(assert (>= 1 x_991)) -(assert (<= 0 x_992)) -(assert (>= 1 x_992)) -(assert (<= 0 x_993)) -(assert (>= 1 x_993)) -(assert (<= 0 x_994)) -(assert (>= 1 x_994)) -(assert (<= 0 x_996)) -(assert (>= 1 x_996)) -(assert (<= 0 x_997)) -(assert (>= 1 x_997)) -(assert (<= 0 x_998)) -(assert (>= 1 x_998)) -(assert (<= 0 x_999)) -(assert (>= 1 x_999)) -(assert (<= 0 x_1001)) -(assert (>= 1 x_1001)) -(assert (<= 0 x_1202)) -(assert (>= 1 x_1202)) -(assert (<= 0 x_1403)) -(assert (>= 1 x_1403)) -(assert (<= 0 x_1604)) -(assert (>= 1 x_1604)) -(assert (= 1 (+ x_1 x_2 x_3 x_4))) -(assert (= 1 (+ x_6 x_7 x_8 x_9))) -(assert (= 1 (+ x_11 x_12 x_13 x_14))) -(assert (= 1 (+ x_16 x_17 x_18 x_19))) -(assert (= 1 (+ x_21 x_22 x_23 x_24))) -(assert (= 1 (+ x_26 x_27 x_28 x_29))) -(assert (= 1 (+ x_31 x_32 x_33 x_34))) -(assert (= 1 (+ x_36 x_37 x_38 x_39))) -(assert (= 1 (+ x_41 x_42 x_43 x_44))) -(assert (= 1 (+ x_46 x_47 x_48 x_49))) -(assert (= 1 (+ x_51 x_52 x_53 x_54))) -(assert (= 1 (+ x_56 x_57 x_58 x_59))) -(assert (= 1 (+ x_61 x_62 x_63 x_64))) -(assert (= 1 (+ x_66 x_67 x_68 x_69))) -(assert (= 1 (+ x_71 x_72 x_73 x_74))) -(assert (= 1 (+ x_76 x_77 x_78 x_79))) -(assert (= 1 (+ x_81 x_82 x_83 x_84))) -(assert (= 1 (+ x_86 x_87 x_88 x_89))) -(assert (= 1 (+ x_91 x_92 x_93 x_94))) -(assert (= 1 (+ x_96 x_97 x_98 x_99))) -(assert (= 1 (+ x_101 x_102 x_103 x_104))) -(assert (= 1 (+ x_106 x_107 x_108 x_109))) -(assert (= 1 (+ x_111 x_112 x_113 x_114))) -(assert (= 1 (+ x_116 x_117 x_118 x_119))) -(assert (= 1 (+ x_121 x_122 x_123 x_124))) -(assert (= 1 (+ x_126 x_127 x_128 x_129))) -(assert (= 1 (+ x_131 x_132 x_133 x_134))) -(assert (= 1 (+ x_136 x_137 x_138 x_139))) -(assert (= 1 (+ x_141 x_142 x_143 x_144))) -(assert (= 1 (+ x_146 x_147 x_148 x_149))) -(assert (= 1 (+ x_151 x_152 x_153 x_154))) -(assert (= 1 (+ x_156 x_157 x_158 x_159))) -(assert (= 1 (+ x_161 x_162 x_163 x_164))) -(assert (= 1 (+ x_166 x_167 x_168 x_169))) -(assert (= 1 (+ x_171 x_172 x_173 x_174))) -(assert (= 1 (+ x_176 x_177 x_178 x_179))) -(assert (= 1 (+ x_181 x_182 x_183 x_184))) -(assert (= 1 (+ x_186 x_187 x_188 x_189))) -(assert (= 1 (+ x_191 x_192 x_193 x_194))) -(assert (= 1 (+ x_196 x_197 x_198 x_199))) -(assert (= 1 (+ x_201 x_202 x_203 x_204))) -(assert (= 1 (+ x_206 x_207 x_208 x_209))) -(assert (= 1 (+ x_211 x_212 x_213 x_214))) -(assert (= 1 (+ x_216 x_217 x_218 x_219))) -(assert (= 1 (+ x_221 x_222 x_223 x_224))) -(assert (= 1 (+ x_226 x_227 x_228 x_229))) -(assert (= 1 (+ x_231 x_232 x_233 x_234))) -(assert (= 1 (+ x_236 x_237 x_238 x_239))) -(assert (= 1 (+ x_241 x_242 x_243 x_244))) -(assert (= 1 (+ x_246 x_247 x_248 x_249))) -(assert (= 1 (+ x_251 x_252 x_253 x_254))) -(assert (= 1 (+ x_256 x_257 x_258 x_259))) -(assert (= 1 (+ x_261 x_262 x_263 x_264))) -(assert (= 1 (+ x_266 x_267 x_268 x_269))) -(assert (= 1 (+ x_271 x_272 x_273 x_274))) -(assert (= 1 (+ x_276 x_277 x_278 x_279))) -(assert (= 1 (+ x_281 x_282 x_283 x_284))) -(assert (= 1 (+ x_286 x_287 x_288 x_289))) -(assert (= 1 (+ x_291 x_292 x_293 x_294))) -(assert (= 1 (+ x_296 x_297 x_298 x_299))) -(assert (= 1 (+ x_301 x_302 x_303 x_304))) -(assert (= 1 (+ x_306 x_307 x_308 x_309))) -(assert (= 1 (+ x_311 x_312 x_313 x_314))) -(assert (= 1 (+ x_316 x_317 x_318 x_319))) -(assert (= 1 (+ x_321 x_322 x_323 x_324))) -(assert (= 1 (+ x_326 x_327 x_328 x_329))) -(assert (= 1 (+ x_331 x_332 x_333 x_334))) -(assert (= 1 (+ x_336 x_337 x_338 x_339))) -(assert (= 1 (+ x_341 x_342 x_343 x_344))) -(assert (= 1 (+ x_346 x_347 x_348 x_349))) -(assert (= 1 (+ x_351 x_352 x_353 x_354))) -(assert (= 1 (+ x_356 x_357 x_358 x_359))) -(assert (= 1 (+ x_361 x_362 x_363 x_364))) -(assert (= 1 (+ x_366 x_367 x_368 x_369))) -(assert (= 1 (+ x_371 x_372 x_373 x_374))) -(assert (= 1 (+ x_376 x_377 x_378 x_379))) -(assert (= 1 (+ x_381 x_382 x_383 x_384))) -(assert (= 1 (+ x_386 x_387 x_388 x_389))) -(assert (= 1 (+ x_391 x_392 x_393 x_394))) -(assert (= 1 (+ x_396 x_397 x_398 x_399))) -(assert (= 1 (+ x_401 x_402 x_403 x_404))) -(assert (= 1 (+ x_406 x_407 x_408 x_409))) -(assert (= 1 (+ x_411 x_412 x_413 x_414))) -(assert (= 1 (+ x_416 x_417 x_418 x_419))) -(assert (= 1 (+ x_421 x_422 x_423 x_424))) -(assert (= 1 (+ x_426 x_427 x_428 x_429))) -(assert (= 1 (+ x_431 x_432 x_433 x_434))) -(assert (= 1 (+ x_436 x_437 x_438 x_439))) -(assert (= 1 (+ x_441 x_442 x_443 x_444))) -(assert (= 1 (+ x_446 x_447 x_448 x_449))) -(assert (= 1 (+ x_451 x_452 x_453 x_454))) -(assert (= 1 (+ x_456 x_457 x_458 x_459))) -(assert (= 1 (+ x_461 x_462 x_463 x_464))) -(assert (= 1 (+ x_466 x_467 x_468 x_469))) -(assert (= 1 (+ x_471 x_472 x_473 x_474))) -(assert (= 1 (+ x_476 x_477 x_478 x_479))) -(assert (= 1 (+ x_481 x_482 x_483 x_484))) -(assert (= 1 (+ x_486 x_487 x_488 x_489))) -(assert (= 1 (+ x_491 x_492 x_493 x_494))) -(assert (= 1 (+ x_496 x_497 x_498 x_499))) -(assert (= 1 (+ x_501 x_502 x_503 x_504))) -(assert (= 1 (+ x_506 x_507 x_508 x_509))) -(assert (= 1 (+ x_511 x_512 x_513 x_514))) -(assert (= 1 (+ x_516 x_517 x_518 x_519))) -(assert (= 1 (+ x_521 x_522 x_523 x_524))) -(assert (= 1 (+ x_526 x_527 x_528 x_529))) -(assert (= 1 (+ x_531 x_532 x_533 x_534))) -(assert (= 1 (+ x_536 x_537 x_538 x_539))) -(assert (= 1 (+ x_541 x_542 x_543 x_544))) -(assert (= 1 (+ x_546 x_547 x_548 x_549))) -(assert (= 1 (+ x_551 x_552 x_553 x_554))) -(assert (= 1 (+ x_556 x_557 x_558 x_559))) -(assert (= 1 (+ x_561 x_562 x_563 x_564))) -(assert (= 1 (+ x_566 x_567 x_568 x_569))) -(assert (= 1 (+ x_571 x_572 x_573 x_574))) -(assert (= 1 (+ x_576 x_577 x_578 x_579))) -(assert (= 1 (+ x_581 x_582 x_583 x_584))) -(assert (= 1 (+ x_586 x_587 x_588 x_589))) -(assert (= 1 (+ x_591 x_592 x_593 x_594))) -(assert (= 1 (+ x_596 x_597 x_598 x_599))) -(assert (= 1 (+ x_601 x_602 x_603 x_604))) -(assert (= 1 (+ x_606 x_607 x_608 x_609))) -(assert (= 1 (+ x_611 x_612 x_613 x_614))) -(assert (= 1 (+ x_616 x_617 x_618 x_619))) -(assert (= 1 (+ x_621 x_622 x_623 x_624))) -(assert (= 1 (+ x_626 x_627 x_628 x_629))) -(assert (= 1 (+ x_631 x_632 x_633 x_634))) -(assert (= 1 (+ x_636 x_637 x_638 x_639))) -(assert (= 1 (+ x_641 x_642 x_643 x_644))) -(assert (= 1 (+ x_646 x_647 x_648 x_649))) -(assert (= 1 (+ x_651 x_652 x_653 x_654))) -(assert (= 1 (+ x_656 x_657 x_658 x_659))) -(assert (= 1 (+ x_661 x_662 x_663 x_664))) -(assert (= 1 (+ x_666 x_667 x_668 x_669))) -(assert (= 1 (+ x_671 x_672 x_673 x_674))) -(assert (= 1 (+ x_676 x_677 x_678 x_679))) -(assert (= 1 (+ x_681 x_682 x_683 x_684))) -(assert (= 1 (+ x_686 x_687 x_688 x_689))) -(assert (= 1 (+ x_691 x_692 x_693 x_694))) -(assert (= 1 (+ x_696 x_697 x_698 x_699))) -(assert (= 1 (+ x_701 x_702 x_703 x_704))) -(assert (= 1 (+ x_706 x_707 x_708 x_709))) -(assert (= 1 (+ x_711 x_712 x_713 x_714))) -(assert (= 1 (+ x_716 x_717 x_718 x_719))) -(assert (= 1 (+ x_721 x_722 x_723 x_724))) -(assert (= 1 (+ x_726 x_727 x_728 x_729))) -(assert (= 1 (+ x_731 x_732 x_733 x_734))) -(assert (= 1 (+ x_736 x_737 x_738 x_739))) -(assert (= 1 (+ x_741 x_742 x_743 x_744))) -(assert (= 1 (+ x_746 x_747 x_748 x_749))) -(assert (= 1 (+ x_751 x_752 x_753 x_754))) -(assert (= 1 (+ x_756 x_757 x_758 x_759))) -(assert (= 1 (+ x_761 x_762 x_763 x_764))) -(assert (= 1 (+ x_766 x_767 x_768 x_769))) -(assert (= 1 (+ x_771 x_772 x_773 x_774))) -(assert (= 1 (+ x_776 x_777 x_778 x_779))) -(assert (= 1 (+ x_781 x_782 x_783 x_784))) -(assert (= 1 (+ x_786 x_787 x_788 x_789))) -(assert (= 1 (+ x_791 x_792 x_793 x_794))) -(assert (= 1 (+ x_796 x_797 x_798 x_799))) -(assert (= 1 (+ x_801 x_802 x_803 x_804))) -(assert (= 1 (+ x_806 x_807 x_808 x_809))) -(assert (= 1 (+ x_811 x_812 x_813 x_814))) -(assert (= 1 (+ x_816 x_817 x_818 x_819))) -(assert (= 1 (+ x_821 x_822 x_823 x_824))) -(assert (= 1 (+ x_826 x_827 x_828 x_829))) -(assert (= 1 (+ x_831 x_832 x_833 x_834))) -(assert (= 1 (+ x_836 x_837 x_838 x_839))) -(assert (= 1 (+ x_841 x_842 x_843 x_844))) -(assert (= 1 (+ x_846 x_847 x_848 x_849))) -(assert (= 1 (+ x_851 x_852 x_853 x_854))) -(assert (= 1 (+ x_856 x_857 x_858 x_859))) -(assert (= 1 (+ x_861 x_862 x_863 x_864))) -(assert (= 1 (+ x_866 x_867 x_868 x_869))) -(assert (= 1 (+ x_871 x_872 x_873 x_874))) -(assert (= 1 (+ x_876 x_877 x_878 x_879))) -(assert (= 1 (+ x_881 x_882 x_883 x_884))) -(assert (= 1 (+ x_886 x_887 x_888 x_889))) -(assert (= 1 (+ x_891 x_892 x_893 x_894))) -(assert (= 1 (+ x_896 x_897 x_898 x_899))) -(assert (= 1 (+ x_901 x_902 x_903 x_904))) -(assert (= 1 (+ x_906 x_907 x_908 x_909))) -(assert (= 1 (+ x_911 x_912 x_913 x_914))) -(assert (= 1 (+ x_916 x_917 x_918 x_919))) -(assert (= 1 (+ x_921 x_922 x_923 x_924))) -(assert (= 1 (+ x_926 x_927 x_928 x_929))) -(assert (= 1 (+ x_931 x_932 x_933 x_934))) -(assert (= 1 (+ x_936 x_937 x_938 x_939))) -(assert (= 1 (+ x_941 x_942 x_943 x_944))) -(assert (= 1 (+ x_946 x_947 x_948 x_949))) -(assert (= 1 (+ x_951 x_952 x_953 x_954))) -(assert (= 1 (+ x_956 x_957 x_958 x_959))) -(assert (= 1 (+ x_961 x_962 x_963 x_964))) -(assert (= 1 (+ x_966 x_967 x_968 x_969))) -(assert (= 1 (+ x_971 x_972 x_973 x_974))) -(assert (= 1 (+ x_976 x_977 x_978 x_979))) -(assert (= 1 (+ x_981 x_982 x_983 x_984))) -(assert (= 1 (+ x_986 x_987 x_988 x_989))) -(assert (= 1 (+ x_991 x_992 x_993 x_994))) -(assert (= 1 (+ x_996 x_997 x_998 x_999))) -(assert (<= 0 (+ x_1001 (* (- 1) x_4)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_9)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_14)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_19)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_24)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_29)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_34)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_39)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_44)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_49)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_54)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_59)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_64)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_69)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_74)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_79)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_84)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_89)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_94)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_99)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_104)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_109)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_114)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_119)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_124)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_129)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_134)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_139)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_144)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_149)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_154)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_159)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_164)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_169)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_174)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_179)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_184)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_189)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_194)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_199)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_204)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_209)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_214)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_219)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_224)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_229)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_234)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_239)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_244)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_249)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_254)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_259)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_264)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_269)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_274)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_279)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_284)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_289)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_294)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_299)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_304)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_309)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_314)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_319)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_324)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_329)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_334)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_339)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_344)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_349)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_354)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_359)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_364)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_369)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_374)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_379)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_384)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_389)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_394)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_399)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_404)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_409)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_414)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_419)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_424)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_429)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_434)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_439)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_444)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_449)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_454)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_459)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_464)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_469)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_474)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_479)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_484)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_489)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_494)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_499)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_504)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_509)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_514)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_519)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_524)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_529)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_534)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_539)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_544)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_549)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_554)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_559)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_564)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_569)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_574)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_579)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_584)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_589)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_594)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_599)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_604)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_609)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_614)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_619)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_624)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_629)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_634)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_639)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_644)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_649)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_654)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_659)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_664)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_669)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_674)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_679)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_684)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_689)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_694)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_699)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_704)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_709)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_714)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_719)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_724)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_729)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_734)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_739)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_744)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_749)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_754)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_759)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_764)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_769)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_774)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_779)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_784)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_789)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_794)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_799)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_804)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_809)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_814)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_819)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_824)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_829)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_834)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_839)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_844)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_849)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_854)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_859)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_864)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_869)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_874)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_879)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_884)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_889)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_894)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_899)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_904)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_909)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_914)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_919)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_924)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_929)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_934)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_939)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_944)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_949)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_954)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_959)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_964)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_969)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_974)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_979)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_984)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_989)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_994)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_999)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_1)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_6)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_11)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_16)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_21)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_26)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_31)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_36)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_41)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_46)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_51)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_56)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_61)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_66)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_71)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_76)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_81)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_86)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_91)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_96)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_101)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_106)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_111)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_116)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_121)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_126)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_131)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_136)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_141)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_146)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_151)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_156)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_161)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_166)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_171)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_176)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_181)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_186)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_191)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_196)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_201)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_206)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_211)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_216)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_221)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_226)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_231)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_236)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_241)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_246)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_251)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_256)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_261)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_266)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_271)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_276)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_281)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_286)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_291)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_296)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_301)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_306)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_311)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_316)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_321)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_326)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_331)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_336)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_341)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_346)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_351)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_356)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_361)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_366)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_371)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_376)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_381)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_386)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_391)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_396)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_401)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_406)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_411)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_416)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_421)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_426)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_431)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_436)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_441)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_446)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_451)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_456)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_461)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_466)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_471)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_476)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_481)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_486)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_491)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_496)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_501)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_506)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_511)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_516)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_521)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_526)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_531)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_536)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_541)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_546)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_551)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_556)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_561)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_566)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_571)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_576)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_581)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_586)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_591)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_596)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_601)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_606)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_611)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_616)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_621)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_626)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_631)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_636)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_641)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_646)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_651)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_656)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_661)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_666)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_671)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_676)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_681)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_686)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_691)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_696)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_701)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_706)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_711)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_716)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_721)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_726)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_731)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_736)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_741)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_746)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_751)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_756)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_761)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_766)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_771)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_776)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_781)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_786)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_791)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_796)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_801)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_806)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_811)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_816)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_821)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_826)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_831)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_836)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_841)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_846)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_851)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_856)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_861)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_866)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_871)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_876)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_881)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_886)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_891)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_896)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_901)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_906)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_911)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_916)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_921)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_926)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_931)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_936)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_941)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_946)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_951)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_956)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_961)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_966)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_971)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_976)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_981)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_986)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_991)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_996)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_2)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_7)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_12)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_17)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_22)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_27)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_32)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_37)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_42)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_47)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_52)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_57)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_62)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_67)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_72)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_77)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_82)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_87)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_92)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_97)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_102)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_107)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_112)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_117)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_122)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_127)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_132)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_137)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_142)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_147)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_152)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_157)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_162)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_167)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_172)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_177)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_182)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_187)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_192)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_197)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_202)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_207)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_212)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_217)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_222)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_227)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_232)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_237)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_242)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_247)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_252)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_257)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_262)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_267)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_272)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_277)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_282)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_287)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_292)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_297)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_302)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_307)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_312)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_317)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_322)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_327)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_332)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_337)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_342)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_347)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_352)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_357)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_362)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_367)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_372)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_377)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_382)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_387)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_392)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_397)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_402)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_407)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_412)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_417)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_422)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_427)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_432)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_437)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_442)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_447)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_452)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_457)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_462)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_467)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_472)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_477)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_482)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_487)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_492)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_497)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_502)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_507)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_512)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_517)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_522)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_527)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_532)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_537)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_542)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_547)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_552)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_557)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_562)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_567)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_572)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_577)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_582)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_587)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_592)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_597)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_602)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_607)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_612)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_617)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_622)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_627)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_632)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_637)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_642)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_647)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_652)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_657)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_662)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_667)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_672)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_677)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_682)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_687)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_692)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_697)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_702)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_707)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_712)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_717)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_722)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_727)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_732)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_737)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_742)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_747)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_752)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_757)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_762)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_767)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_772)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_777)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_782)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_787)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_792)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_797)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_802)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_807)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_812)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_817)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_822)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_827)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_832)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_837)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_842)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_847)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_852)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_857)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_862)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_867)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_872)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_877)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_882)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_887)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_892)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_897)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_902)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_907)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_912)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_917)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_922)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_927)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_932)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_937)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_942)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_947)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_952)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_957)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_962)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_967)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_972)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_977)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_982)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_987)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_992)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_997)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_3)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_8)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_13)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_18)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_23)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_28)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_33)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_38)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_43)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_48)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_53)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_58)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_63)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_68)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_73)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_78)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_83)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_88)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_93)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_98)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_103)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_108)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_113)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_118)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_123)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_128)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_133)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_138)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_143)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_148)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_153)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_158)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_163)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_168)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_173)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_178)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_183)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_188)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_193)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_198)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_203)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_208)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_213)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_218)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_223)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_228)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_233)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_238)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_243)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_248)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_253)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_258)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_263)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_268)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_273)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_278)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_283)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_288)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_293)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_298)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_303)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_308)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_313)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_318)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_323)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_328)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_333)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_338)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_343)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_348)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_353)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_358)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_363)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_368)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_373)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_378)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_383)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_388)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_393)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_398)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_403)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_408)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_413)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_418)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_423)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_428)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_433)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_438)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_443)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_448)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_453)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_458)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_463)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_468)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_473)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_478)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_483)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_488)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_493)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_498)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_503)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_508)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_513)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_518)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_523)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_528)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_533)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_538)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_543)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_548)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_553)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_558)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_563)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_568)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_573)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_578)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_583)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_588)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_593)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_598)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_603)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_608)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_613)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_618)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_623)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_628)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_633)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_638)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_643)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_648)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_653)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_658)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_663)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_668)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_673)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_678)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_683)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_688)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_693)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_698)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_703)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_708)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_713)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_718)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_723)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_728)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_733)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_738)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_743)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_748)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_753)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_758)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_763)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_768)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_773)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_778)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_783)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_788)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_793)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_798)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_803)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_808)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_813)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_818)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_823)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_828)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_833)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_838)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_843)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_848)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_853)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_858)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_863)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_868)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_873)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_878)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_883)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_888)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_893)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_898)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_903)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_908)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_913)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_918)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_923)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_928)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_933)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_938)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_943)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_948)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_953)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_958)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_963)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_968)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_973)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_978)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_983)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_988)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_993)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_998)))) -(assert (<= 0 - (+ (* 21600 x_1001) - (* (- 50) x_9) - (* (- 40) x_14) - (* (- 50) x_19) - (* (- 60) x_24) - (* (- 40) x_29) - (* (- 40) x_34) - (* (- 50) x_39) - (* (- 40) x_44) - (* (- 40) x_49) - (* (- 40) x_54) - (* (- 50) x_59) - (* (- 40) x_64) - (* (- 40) x_69) - (* (- 50) x_74) - (* (- 60) x_79) - (* (- 70) x_84) - (* (- 80) x_89) - (* (- 90) x_94) - (* (- 100) x_99) - (* (- 40) x_104) - (* (- 50) x_109) - (* (- 60) x_114) - (* (- 70) x_119) - (* (- 40) x_124) - (* (- 50) x_129) - (* (- 60) x_134) - (* (- 70) x_139) - (* (- 80) x_144) - (* (- 90) x_149) - (* (- 100) x_154) - (* (- 110) x_159) - (* (- 120) x_164) - (* (- 40) x_169) - (* (- 50) x_174) - (* (- 60) x_179) - (* (- 70) x_184) - (* (- 40) x_189) - (* (- 50) x_194) - (* (- 60) x_199) - (* (- 40) x_204) - (* (- 50) x_209) - (* (- 40) x_214) - (* (- 50) x_219) - (* (- 60) x_224) - (* (- 70) x_229) - (* (- 80) x_234) - (* (- 90) x_239) - (* (- 100) x_244) - (* (- 110) x_249) - (* (- 40) x_254) - (* (- 50) x_259) - (* (- 60) x_264) - (* (- 70) x_269) - (* (- 80) x_274) - (* (- 90) x_279) - (* (- 100) x_284) - (* (- 40) x_289) - (* (- 50) x_294) - (* (- 60) x_299) - (* (- 70) x_304) - (* (- 80) x_309) - (* (- 90) x_314) - (* (- 100) x_319) - (* (- 110) x_324) - (* (- 40) x_329) - (* (- 50) x_334) - (* (- 60) x_339) - (* (- 70) x_344) - (* (- 80) x_349) - (* (- 90) x_354) - (* (- 100) x_359) - (* (- 40) x_364) - (* (- 50) x_369) - (* (- 60) x_374) - (* (- 70) x_379) - (* (- 80) x_384) - (* (- 90) x_389) - (* (- 100) x_394) - (* (- 40) x_399) - (* (- 50) x_404) - (* (- 60) x_409) - (* (- 40) x_414) - (* (- 50) x_419) - (* (- 60) x_424) - (* (- 70) x_429) - (* (- 80) x_434) - (* (- 90) x_439) - (* (- 100) x_444) - (* (- 110) x_449) - (* (- 120) x_454) - (* (- 130) x_459) - (* (- 40) x_464) - (* (- 50) x_469) - (* (- 60) x_474) - (* (- 70) x_479) - (* (- 80) x_484) - (* (- 90) x_489) - (* (- 40) x_494) - (* (- 40) x_499) - (* (- 50) x_504) - (* (- 60) x_509) - (* (- 70) x_514) - (* (- 80) x_519) - (* (- 90) x_524) - (* (- 40) x_529) - (* (- 50) x_534) - (* (- 60) x_539) - (* (- 40) x_544) - (* (- 50) x_549) - (* (- 60) x_554) - (* (- 70) x_559) - (* (- 40) x_564) - (* (- 50) x_569) - (* (- 60) x_574) - (* (- 70) x_579) - (* (- 80) x_584) - (* (- 90) x_589) - (* (- 40) x_594) - (* (- 40) x_599) - (* (- 50) x_604) - (* (- 60) x_609) - (* (- 70) x_614) - (* (- 80) x_619) - (* (- 40) x_624) - (* (- 50) x_629) - (* (- 60) x_634) - (* (- 70) x_639) - (* (- 80) x_644) - (* (- 90) x_649) - (* (- 100) x_654) - (* (- 110) x_659) - (* (- 40) x_664) - (* (- 50) x_669) - (* (- 60) x_674) - (* (- 70) x_679) - (* (- 40) x_684) - (* (- 50) x_689) - (* (- 60) x_694) - (* (- 70) x_699) - (* (- 80) x_704) - (* (- 90) x_709) - (* (- 100) x_714) - (* (- 110) x_719) - (* (- 120) x_724) - (* (- 40) x_729) - (* (- 50) x_734) - (* (- 60) x_739) - (* (- 70) x_744) - (* (- 80) x_749) - (* (- 90) x_754) - (* (- 100) x_759) - (* (- 110) x_764) - (* (- 40) x_769) - (* (- 50) x_774) - (* (- 40) x_779) - (* (- 50) x_784) - (* (- 40) x_789) - (* (- 50) x_794) - (* (- 60) x_799) - (* (- 70) x_804) - (* (- 80) x_809) - (* (- 90) x_814) - (* (- 100) x_819) - (* (- 40) x_824) - (* (- 50) x_829) - (* (- 60) x_834) - (* (- 70) x_839) - (* (- 80) x_844) - (* (- 90) x_849) - (* (- 100) x_854) - (* (- 110) x_859) - (* (- 40) x_864) - (* (- 50) x_869) - (* (- 60) x_874) - (* (- 70) x_879) - (* (- 80) x_884) - (* (- 90) x_889) - (* (- 40) x_894) - (* (- 50) x_899) - (* (- 60) x_904) - (* (- 70) x_909) - (* (- 80) x_914) - (* (- 90) x_919) - (* (- 100) x_924) - (* (- 52) x_929) - (* (- 52) x_934) - (* (- 65) x_939) - (* (- 52) x_944) - (* (- 52) x_949) - (* (- 65) x_954) - (* (- 52) x_959) - (* (- 65) x_964) - (* (- 52) x_969) - (* (- 65) x_974) - (* (- 78) x_979) - (* (- 91) x_984) - (* (- 104) x_989) - (* (- 117) x_994) - (* (- 130) x_999) - (* (- 40) x_4)))) -(assert (<= 0 - (+ (* 7400 x_1202) - (* (- 50) x_6) - (* (- 40) x_11) - (* (- 50) x_16) - (* (- 60) x_21) - (* (- 40) x_26) - (* (- 40) x_31) - (* (- 50) x_36) - (* (- 40) x_41) - (* (- 40) x_46) - (* (- 40) x_51) - (* (- 50) x_56) - (* (- 40) x_61) - (* (- 40) x_66) - (* (- 50) x_71) - (* (- 60) x_76) - (* (- 70) x_81) - (* (- 80) x_86) - (* (- 90) x_91) - (* (- 100) x_96) - (* (- 40) x_101) - (* (- 50) x_106) - (* (- 60) x_111) - (* (- 70) x_116) - (* (- 40) x_121) - (* (- 50) x_126) - (* (- 60) x_131) - (* (- 70) x_136) - (* (- 80) x_141) - (* (- 90) x_146) - (* (- 100) x_151) - (* (- 110) x_156) - (* (- 120) x_161) - (* (- 40) x_166) - (* (- 50) x_171) - (* (- 60) x_176) - (* (- 70) x_181) - (* (- 40) x_186) - (* (- 50) x_191) - (* (- 60) x_196) - (* (- 40) x_201) - (* (- 50) x_206) - (* (- 40) x_211) - (* (- 50) x_216) - (* (- 60) x_221) - (* (- 70) x_226) - (* (- 80) x_231) - (* (- 90) x_236) - (* (- 100) x_241) - (* (- 110) x_246) - (* (- 40) x_251) - (* (- 50) x_256) - (* (- 60) x_261) - (* (- 70) x_266) - (* (- 80) x_271) - (* (- 90) x_276) - (* (- 100) x_281) - (* (- 40) x_286) - (* (- 50) x_291) - (* (- 60) x_296) - (* (- 70) x_301) - (* (- 80) x_306) - (* (- 90) x_311) - (* (- 100) x_316) - (* (- 110) x_321) - (* (- 40) x_326) - (* (- 50) x_331) - (* (- 60) x_336) - (* (- 70) x_341) - (* (- 80) x_346) - (* (- 90) x_351) - (* (- 100) x_356) - (* (- 40) x_361) - (* (- 50) x_366) - (* (- 60) x_371) - (* (- 70) x_376) - (* (- 80) x_381) - (* (- 90) x_386) - (* (- 100) x_391) - (* (- 40) x_396) - (* (- 50) x_401) - (* (- 60) x_406) - (* (- 40) x_411) - (* (- 50) x_416) - (* (- 60) x_421) - (* (- 70) x_426) - (* (- 80) x_431) - (* (- 90) x_436) - (* (- 100) x_441) - (* (- 110) x_446) - (* (- 120) x_451) - (* (- 130) x_456) - (* (- 40) x_461) - (* (- 50) x_466) - (* (- 60) x_471) - (* (- 70) x_476) - (* (- 80) x_481) - (* (- 90) x_486) - (* (- 40) x_491) - (* (- 40) x_496) - (* (- 50) x_501) - (* (- 60) x_506) - (* (- 70) x_511) - (* (- 80) x_516) - (* (- 90) x_521) - (* (- 40) x_526) - (* (- 50) x_531) - (* (- 60) x_536) - (* (- 40) x_541) - (* (- 50) x_546) - (* (- 60) x_551) - (* (- 70) x_556) - (* (- 40) x_561) - (* (- 50) x_566) - (* (- 60) x_571) - (* (- 70) x_576) - (* (- 80) x_581) - (* (- 90) x_586) - (* (- 40) x_591) - (* (- 40) x_596) - (* (- 50) x_601) - (* (- 60) x_606) - (* (- 70) x_611) - (* (- 80) x_616) - (* (- 40) x_621) - (* (- 50) x_626) - (* (- 60) x_631) - (* (- 70) x_636) - (* (- 80) x_641) - (* (- 90) x_646) - (* (- 100) x_651) - (* (- 110) x_656) - (* (- 40) x_661) - (* (- 50) x_666) - (* (- 60) x_671) - (* (- 70) x_676) - (* (- 40) x_681) - (* (- 50) x_686) - (* (- 60) x_691) - (* (- 70) x_696) - (* (- 80) x_701) - (* (- 90) x_706) - (* (- 100) x_711) - (* (- 110) x_716) - (* (- 120) x_721) - (* (- 40) x_726) - (* (- 50) x_731) - (* (- 60) x_736) - (* (- 70) x_741) - (* (- 80) x_746) - (* (- 90) x_751) - (* (- 100) x_756) - (* (- 110) x_761) - (* (- 40) x_766) - (* (- 50) x_771) - (* (- 40) x_776) - (* (- 50) x_781) - (* (- 40) x_786) - (* (- 50) x_791) - (* (- 60) x_796) - (* (- 70) x_801) - (* (- 80) x_806) - (* (- 90) x_811) - (* (- 100) x_816) - (* (- 40) x_821) - (* (- 50) x_826) - (* (- 60) x_831) - (* (- 70) x_836) - (* (- 80) x_841) - (* (- 90) x_846) - (* (- 100) x_851) - (* (- 110) x_856) - (* (- 40) x_861) - (* (- 50) x_866) - (* (- 60) x_871) - (* (- 70) x_876) - (* (- 80) x_881) - (* (- 90) x_886) - (* (- 40) x_891) - (* (- 50) x_896) - (* (- 60) x_901) - (* (- 70) x_906) - (* (- 80) x_911) - (* (- 90) x_916) - (* (- 100) x_921) - (* (- 52) x_926) - (* (- 52) x_931) - (* (- 65) x_936) - (* (- 52) x_941) - (* (- 52) x_946) - (* (- 65) x_951) - (* (- 52) x_956) - (* (- 65) x_961) - (* (- 52) x_966) - (* (- 65) x_971) - (* (- 78) x_976) - (* (- 91) x_981) - (* (- 104) x_986) - (* (- 117) x_991) - (* (- 130) x_996) - (* (- 40) x_1)))) -(assert (<= 0 - (+ (* 26500 x_1403) - (* (- 50) x_7) - (* (- 40) x_12) - (* (- 50) x_17) - (* (- 60) x_22) - (* (- 40) x_27) - (* (- 40) x_32) - (* (- 50) x_37) - (* (- 40) x_42) - (* (- 40) x_47) - (* (- 40) x_52) - (* (- 50) x_57) - (* (- 40) x_62) - (* (- 40) x_67) - (* (- 50) x_72) - (* (- 60) x_77) - (* (- 70) x_82) - (* (- 80) x_87) - (* (- 90) x_92) - (* (- 100) x_97) - (* (- 40) x_102) - (* (- 50) x_107) - (* (- 60) x_112) - (* (- 70) x_117) - (* (- 40) x_122) - (* (- 50) x_127) - (* (- 60) x_132) - (* (- 70) x_137) - (* (- 80) x_142) - (* (- 90) x_147) - (* (- 100) x_152) - (* (- 110) x_157) - (* (- 120) x_162) - (* (- 40) x_167) - (* (- 50) x_172) - (* (- 60) x_177) - (* (- 70) x_182) - (* (- 40) x_187) - (* (- 50) x_192) - (* (- 60) x_197) - (* (- 40) x_202) - (* (- 50) x_207) - (* (- 40) x_212) - (* (- 50) x_217) - (* (- 60) x_222) - (* (- 70) x_227) - (* (- 80) x_232) - (* (- 90) x_237) - (* (- 100) x_242) - (* (- 110) x_247) - (* (- 40) x_252) - (* (- 50) x_257) - (* (- 60) x_262) - (* (- 70) x_267) - (* (- 80) x_272) - (* (- 90) x_277) - (* (- 100) x_282) - (* (- 40) x_287) - (* (- 50) x_292) - (* (- 60) x_297) - (* (- 70) x_302) - (* (- 80) x_307) - (* (- 90) x_312) - (* (- 100) x_317) - (* (- 110) x_322) - (* (- 40) x_327) - (* (- 50) x_332) - (* (- 60) x_337) - (* (- 70) x_342) - (* (- 80) x_347) - (* (- 90) x_352) - (* (- 100) x_357) - (* (- 40) x_362) - (* (- 50) x_367) - (* (- 60) x_372) - (* (- 70) x_377) - (* (- 80) x_382) - (* (- 90) x_387) - (* (- 100) x_392) - (* (- 40) x_397) - (* (- 50) x_402) - (* (- 60) x_407) - (* (- 40) x_412) - (* (- 50) x_417) - (* (- 60) x_422) - (* (- 70) x_427) - (* (- 80) x_432) - (* (- 90) x_437) - (* (- 100) x_442) - (* (- 110) x_447) - (* (- 120) x_452) - (* (- 130) x_457) - (* (- 40) x_462) - (* (- 50) x_467) - (* (- 60) x_472) - (* (- 70) x_477) - (* (- 80) x_482) - (* (- 90) x_487) - (* (- 40) x_492) - (* (- 40) x_497) - (* (- 50) x_502) - (* (- 60) x_507) - (* (- 70) x_512) - (* (- 80) x_517) - (* (- 90) x_522) - (* (- 40) x_527) - (* (- 50) x_532) - (* (- 60) x_537) - (* (- 40) x_542) - (* (- 50) x_547) - (* (- 60) x_552) - (* (- 70) x_557) - (* (- 40) x_562) - (* (- 50) x_567) - (* (- 60) x_572) - (* (- 70) x_577) - (* (- 80) x_582) - (* (- 90) x_587) - (* (- 40) x_592) - (* (- 40) x_597) - (* (- 50) x_602) - (* (- 60) x_607) - (* (- 70) x_612) - (* (- 80) x_617) - (* (- 40) x_622) - (* (- 50) x_627) - (* (- 60) x_632) - (* (- 70) x_637) - (* (- 80) x_642) - (* (- 90) x_647) - (* (- 100) x_652) - (* (- 110) x_657) - (* (- 40) x_662) - (* (- 50) x_667) - (* (- 60) x_672) - (* (- 70) x_677) - (* (- 40) x_682) - (* (- 50) x_687) - (* (- 60) x_692) - (* (- 70) x_697) - (* (- 80) x_702) - (* (- 90) x_707) - (* (- 100) x_712) - (* (- 110) x_717) - (* (- 120) x_722) - (* (- 40) x_727) - (* (- 50) x_732) - (* (- 60) x_737) - (* (- 70) x_742) - (* (- 80) x_747) - (* (- 90) x_752) - (* (- 100) x_757) - (* (- 110) x_762) - (* (- 40) x_767) - (* (- 50) x_772) - (* (- 40) x_777) - (* (- 50) x_782) - (* (- 40) x_787) - (* (- 50) x_792) - (* (- 60) x_797) - (* (- 70) x_802) - (* (- 80) x_807) - (* (- 90) x_812) - (* (- 100) x_817) - (* (- 40) x_822) - (* (- 50) x_827) - (* (- 60) x_832) - (* (- 70) x_837) - (* (- 80) x_842) - (* (- 90) x_847) - (* (- 100) x_852) - (* (- 110) x_857) - (* (- 40) x_862) - (* (- 50) x_867) - (* (- 60) x_872) - (* (- 70) x_877) - (* (- 80) x_882) - (* (- 90) x_887) - (* (- 40) x_892) - (* (- 50) x_897) - (* (- 60) x_902) - (* (- 70) x_907) - (* (- 80) x_912) - (* (- 90) x_917) - (* (- 100) x_922) - (* (- 52) x_927) - (* (- 52) x_932) - (* (- 65) x_937) - (* (- 52) x_942) - (* (- 52) x_947) - (* (- 65) x_952) - (* (- 52) x_957) - (* (- 65) x_962) - (* (- 52) x_967) - (* (- 65) x_972) - (* (- 78) x_977) - (* (- 91) x_982) - (* (- 104) x_987) - (* (- 117) x_992) - (* (- 130) x_997) - (* (- 40) x_2)))) -(assert (<= 0 - (+ (* 4500 x_1604) - (* (- 50) x_8) - (* (- 40) x_13) - (* (- 50) x_18) - (* (- 60) x_23) - (* (- 40) x_28) - (* (- 40) x_33) - (* (- 50) x_38) - (* (- 40) x_43) - (* (- 40) x_48) - (* (- 40) x_53) - (* (- 50) x_58) - (* (- 40) x_63) - (* (- 40) x_68) - (* (- 50) x_73) - (* (- 60) x_78) - (* (- 70) x_83) - (* (- 80) x_88) - (* (- 90) x_93) - (* (- 100) x_98) - (* (- 40) x_103) - (* (- 50) x_108) - (* (- 60) x_113) - (* (- 70) x_118) - (* (- 40) x_123) - (* (- 50) x_128) - (* (- 60) x_133) - (* (- 70) x_138) - (* (- 80) x_143) - (* (- 90) x_148) - (* (- 100) x_153) - (* (- 110) x_158) - (* (- 120) x_163) - (* (- 40) x_168) - (* (- 50) x_173) - (* (- 60) x_178) - (* (- 70) x_183) - (* (- 40) x_188) - (* (- 50) x_193) - (* (- 60) x_198) - (* (- 40) x_203) - (* (- 50) x_208) - (* (- 40) x_213) - (* (- 50) x_218) - (* (- 60) x_223) - (* (- 70) x_228) - (* (- 80) x_233) - (* (- 90) x_238) - (* (- 100) x_243) - (* (- 110) x_248) - (* (- 40) x_253) - (* (- 50) x_258) - (* (- 60) x_263) - (* (- 70) x_268) - (* (- 80) x_273) - (* (- 90) x_278) - (* (- 100) x_283) - (* (- 40) x_288) - (* (- 50) x_293) - (* (- 60) x_298) - (* (- 70) x_303) - (* (- 80) x_308) - (* (- 90) x_313) - (* (- 100) x_318) - (* (- 110) x_323) - (* (- 40) x_328) - (* (- 50) x_333) - (* (- 60) x_338) - (* (- 70) x_343) - (* (- 80) x_348) - (* (- 90) x_353) - (* (- 100) x_358) - (* (- 40) x_363) - (* (- 50) x_368) - (* (- 60) x_373) - (* (- 70) x_378) - (* (- 80) x_383) - (* (- 90) x_388) - (* (- 100) x_393) - (* (- 40) x_398) - (* (- 50) x_403) - (* (- 60) x_408) - (* (- 40) x_413) - (* (- 50) x_418) - (* (- 60) x_423) - (* (- 70) x_428) - (* (- 80) x_433) - (* (- 90) x_438) - (* (- 100) x_443) - (* (- 110) x_448) - (* (- 120) x_453) - (* (- 130) x_458) - (* (- 40) x_463) - (* (- 50) x_468) - (* (- 60) x_473) - (* (- 70) x_478) - (* (- 80) x_483) - (* (- 90) x_488) - (* (- 40) x_493) - (* (- 40) x_498) - (* (- 50) x_503) - (* (- 60) x_508) - (* (- 70) x_513) - (* (- 80) x_518) - (* (- 90) x_523) - (* (- 40) x_528) - (* (- 50) x_533) - (* (- 60) x_538) - (* (- 40) x_543) - (* (- 50) x_548) - (* (- 60) x_553) - (* (- 70) x_558) - (* (- 40) x_563) - (* (- 50) x_568) - (* (- 60) x_573) - (* (- 70) x_578) - (* (- 80) x_583) - (* (- 90) x_588) - (* (- 40) x_593) - (* (- 40) x_598) - (* (- 50) x_603) - (* (- 60) x_608) - (* (- 70) x_613) - (* (- 80) x_618) - (* (- 40) x_623) - (* (- 50) x_628) - (* (- 60) x_633) - (* (- 70) x_638) - (* (- 80) x_643) - (* (- 90) x_648) - (* (- 100) x_653) - (* (- 110) x_658) - (* (- 40) x_663) - (* (- 50) x_668) - (* (- 60) x_673) - (* (- 70) x_678) - (* (- 40) x_683) - (* (- 50) x_688) - (* (- 60) x_693) - (* (- 70) x_698) - (* (- 80) x_703) - (* (- 90) x_708) - (* (- 100) x_713) - (* (- 110) x_718) - (* (- 120) x_723) - (* (- 40) x_728) - (* (- 50) x_733) - (* (- 60) x_738) - (* (- 70) x_743) - (* (- 80) x_748) - (* (- 90) x_753) - (* (- 100) x_758) - (* (- 110) x_763) - (* (- 40) x_768) - (* (- 50) x_773) - (* (- 40) x_778) - (* (- 50) x_783) - (* (- 40) x_788) - (* (- 50) x_793) - (* (- 60) x_798) - (* (- 70) x_803) - (* (- 80) x_808) - (* (- 90) x_813) - (* (- 100) x_818) - (* (- 40) x_823) - (* (- 50) x_828) - (* (- 60) x_833) - (* (- 70) x_838) - (* (- 80) x_843) - (* (- 90) x_848) - (* (- 100) x_853) - (* (- 110) x_858) - (* (- 40) x_863) - (* (- 50) x_868) - (* (- 60) x_873) - (* (- 70) x_878) - (* (- 80) x_883) - (* (- 90) x_888) - (* (- 40) x_893) - (* (- 50) x_898) - (* (- 60) x_903) - (* (- 70) x_908) - (* (- 80) x_913) - (* (- 90) x_918) - (* (- 100) x_923) - (* (- 52) x_928) - (* (- 52) x_933) - (* (- 65) x_938) - (* (- 52) x_943) - (* (- 52) x_948) - (* (- 65) x_953) - (* (- 52) x_958) - (* (- 65) x_963) - (* (- 52) x_968) - (* (- 65) x_973) - (* (- 78) x_978) - (* (- 91) x_983) - (* (- 104) x_988) - (* (- 117) x_993) - (* (- 130) x_998) - (* (- 40) x_3)))) -(assert (<= 0 - (+ (* 3850 x_1001) - (* (- 30) x_9) - (* (- 24) x_14) - (* (- 30) x_19) - (* (- 36) x_24) - (* (- 24) x_29) - (* (- 24) x_34) - (* (- 30) x_39) - (* (- 24) x_44) - (* (- 24) x_49) - (* (- 24) x_54) - (* (- 30) x_59) - (* (- 24) x_64) - (* (- 24) x_69) - (* (- 30) x_74) - (* (- 36) x_79) - (* (- 42) x_84) - (* (- 48) x_89) - (* (- 54) x_94) - (* (- 60) x_99) - (* (- 24) x_104) - (* (- 30) x_109) - (* (- 36) x_114) - (* (- 42) x_119) - (* (- 24) x_124) - (* (- 30) x_129) - (* (- 36) x_134) - (* (- 42) x_139) - (* (- 48) x_144) - (* (- 54) x_149) - (* (- 60) x_154) - (* (- 66) x_159) - (* (- 72) x_164) - (* (- 24) x_169) - (* (- 30) x_174) - (* (- 36) x_179) - (* (- 42) x_184) - (* (- 24) x_189) - (* (- 30) x_194) - (* (- 36) x_199) - (* (- 24) x_204) - (* (- 30) x_209) - (* (- 24) x_214) - (* (- 30) x_219) - (* (- 36) x_224) - (* (- 42) x_229) - (* (- 48) x_234) - (* (- 54) x_239) - (* (- 60) x_244) - (* (- 66) x_249) - (* (- 24) x_254) - (* (- 30) x_259) - (* (- 36) x_264) - (* (- 42) x_269) - (* (- 48) x_274) - (* (- 54) x_279) - (* (- 60) x_284) - (* (- 24) x_289) - (* (- 30) x_294) - (* (- 36) x_299) - (* (- 42) x_304) - (* (- 48) x_309) - (* (- 54) x_314) - (* (- 60) x_319) - (* (- 66) x_324) - (* (- 24) x_329) - (* (- 30) x_334) - (* (- 36) x_339) - (* (- 42) x_344) - (* (- 48) x_349) - (* (- 54) x_354) - (* (- 60) x_359) - (* (- 24) x_364) - (* (- 30) x_369) - (* (- 36) x_374) - (* (- 42) x_379) - (* (- 48) x_384) - (* (- 54) x_389) - (* (- 60) x_394) - (* (- 24) x_399) - (* (- 30) x_404) - (* (- 36) x_409) - (* (- 24) x_414) - (* (- 30) x_419) - (* (- 36) x_424) - (* (- 42) x_429) - (* (- 48) x_434) - (* (- 54) x_439) - (* (- 60) x_444) - (* (- 66) x_449) - (* (- 72) x_454) - (* (- 78) x_459) - (* (- 24) x_464) - (* (- 30) x_469) - (* (- 36) x_474) - (* (- 42) x_479) - (* (- 48) x_484) - (* (- 54) x_489) - (* (- 24) x_494) - (* (- 24) x_499) - (* (- 30) x_504) - (* (- 36) x_509) - (* (- 42) x_514) - (* (- 48) x_519) - (* (- 54) x_524) - (* (- 24) x_529) - (* (- 30) x_534) - (* (- 36) x_539) - (* (- 24) x_544) - (* (- 30) x_549) - (* (- 36) x_554) - (* (- 42) x_559) - (* (- 24) x_564) - (* (- 30) x_569) - (* (- 36) x_574) - (* (- 42) x_579) - (* (- 48) x_584) - (* (- 54) x_589) - (* (- 24) x_594) - (* (- 24) x_599) - (* (- 30) x_604) - (* (- 36) x_609) - (* (- 42) x_614) - (* (- 48) x_619) - (* (- 24) x_624) - (* (- 30) x_629) - (* (- 36) x_634) - (* (- 42) x_639) - (* (- 48) x_644) - (* (- 54) x_649) - (* (- 60) x_654) - (* (- 66) x_659) - (* (- 24) x_664) - (* (- 30) x_669) - (* (- 36) x_674) - (* (- 42) x_679) - (* (- 24) x_684) - (* (- 30) x_689) - (* (- 36) x_694) - (* (- 42) x_699) - (* (- 48) x_704) - (* (- 54) x_709) - (* (- 60) x_714) - (* (- 66) x_719) - (* (- 72) x_724) - (* (- 24) x_729) - (* (- 30) x_734) - (* (- 36) x_739) - (* (- 42) x_744) - (* (- 48) x_749) - (* (- 54) x_754) - (* (- 60) x_759) - (* (- 66) x_764) - (* (- 24) x_769) - (* (- 30) x_774) - (* (- 24) x_779) - (* (- 30) x_784) - (* (- 24) x_789) - (* (- 30) x_794) - (* (- 36) x_799) - (* (- 42) x_804) - (* (- 48) x_809) - (* (- 54) x_814) - (* (- 60) x_819) - (* (- 24) x_824) - (* (- 30) x_829) - (* (- 36) x_834) - (* (- 42) x_839) - (* (- 48) x_844) - (* (- 54) x_849) - (* (- 60) x_854) - (* (- 66) x_859) - (* (- 24) x_864) - (* (- 30) x_869) - (* (- 36) x_874) - (* (- 42) x_879) - (* (- 48) x_884) - (* (- 54) x_889) - (* (- 24) x_894) - (* (- 30) x_899) - (* (- 36) x_904) - (* (- 42) x_909) - (* (- 48) x_914) - (* (- 54) x_919) - (* (- 60) x_924) - (* (- 36) x_929) - (* (- 36) x_934) - (* (- 45) x_939) - (* (- 36) x_944) - (* (- 36) x_949) - (* (- 45) x_954) - (* (- 36) x_959) - (* (- 45) x_964) - (* (- 36) x_969) - (* (- 45) x_974) - (* (- 54) x_979) - (* (- 63) x_984) - (* (- 72) x_989) - (* (- 81) x_994) - (* (- 90) x_999) - (* (- 24) x_4)))) -(assert (<= 0 - (+ (* 3000 x_1202) - (* (- 30) x_6) - (* (- 24) x_11) - (* (- 30) x_16) - (* (- 36) x_21) - (* (- 24) x_26) - (* (- 24) x_31) - (* (- 30) x_36) - (* (- 24) x_41) - (* (- 24) x_46) - (* (- 24) x_51) - (* (- 30) x_56) - (* (- 24) x_61) - (* (- 24) x_66) - (* (- 30) x_71) - (* (- 36) x_76) - (* (- 42) x_81) - (* (- 48) x_86) - (* (- 54) x_91) - (* (- 60) x_96) - (* (- 24) x_101) - (* (- 30) x_106) - (* (- 36) x_111) - (* (- 42) x_116) - (* (- 24) x_121) - (* (- 30) x_126) - (* (- 36) x_131) - (* (- 42) x_136) - (* (- 48) x_141) - (* (- 54) x_146) - (* (- 60) x_151) - (* (- 66) x_156) - (* (- 72) x_161) - (* (- 24) x_166) - (* (- 30) x_171) - (* (- 36) x_176) - (* (- 42) x_181) - (* (- 24) x_186) - (* (- 30) x_191) - (* (- 36) x_196) - (* (- 24) x_201) - (* (- 30) x_206) - (* (- 24) x_211) - (* (- 30) x_216) - (* (- 36) x_221) - (* (- 42) x_226) - (* (- 48) x_231) - (* (- 54) x_236) - (* (- 60) x_241) - (* (- 66) x_246) - (* (- 24) x_251) - (* (- 30) x_256) - (* (- 36) x_261) - (* (- 42) x_266) - (* (- 48) x_271) - (* (- 54) x_276) - (* (- 60) x_281) - (* (- 24) x_286) - (* (- 30) x_291) - (* (- 36) x_296) - (* (- 42) x_301) - (* (- 48) x_306) - (* (- 54) x_311) - (* (- 60) x_316) - (* (- 66) x_321) - (* (- 24) x_326) - (* (- 30) x_331) - (* (- 36) x_336) - (* (- 42) x_341) - (* (- 48) x_346) - (* (- 54) x_351) - (* (- 60) x_356) - (* (- 24) x_361) - (* (- 30) x_366) - (* (- 36) x_371) - (* (- 42) x_376) - (* (- 48) x_381) - (* (- 54) x_386) - (* (- 60) x_391) - (* (- 24) x_396) - (* (- 30) x_401) - (* (- 36) x_406) - (* (- 24) x_411) - (* (- 30) x_416) - (* (- 36) x_421) - (* (- 42) x_426) - (* (- 48) x_431) - (* (- 54) x_436) - (* (- 60) x_441) - (* (- 66) x_446) - (* (- 72) x_451) - (* (- 78) x_456) - (* (- 24) x_461) - (* (- 30) x_466) - (* (- 36) x_471) - (* (- 42) x_476) - (* (- 48) x_481) - (* (- 54) x_486) - (* (- 24) x_491) - (* (- 24) x_496) - (* (- 30) x_501) - (* (- 36) x_506) - (* (- 42) x_511) - (* (- 48) x_516) - (* (- 54) x_521) - (* (- 24) x_526) - (* (- 30) x_531) - (* (- 36) x_536) - (* (- 24) x_541) - (* (- 30) x_546) - (* (- 36) x_551) - (* (- 42) x_556) - (* (- 24) x_561) - (* (- 30) x_566) - (* (- 36) x_571) - (* (- 42) x_576) - (* (- 48) x_581) - (* (- 54) x_586) - (* (- 24) x_591) - (* (- 24) x_596) - (* (- 30) x_601) - (* (- 36) x_606) - (* (- 42) x_611) - (* (- 48) x_616) - (* (- 24) x_621) - (* (- 30) x_626) - (* (- 36) x_631) - (* (- 42) x_636) - (* (- 48) x_641) - (* (- 54) x_646) - (* (- 60) x_651) - (* (- 66) x_656) - (* (- 24) x_661) - (* (- 30) x_666) - (* (- 36) x_671) - (* (- 42) x_676) - (* (- 24) x_681) - (* (- 30) x_686) - (* (- 36) x_691) - (* (- 42) x_696) - (* (- 48) x_701) - (* (- 54) x_706) - (* (- 60) x_711) - (* (- 66) x_716) - (* (- 72) x_721) - (* (- 24) x_726) - (* (- 30) x_731) - (* (- 36) x_736) - (* (- 42) x_741) - (* (- 48) x_746) - (* (- 54) x_751) - (* (- 60) x_756) - (* (- 66) x_761) - (* (- 24) x_766) - (* (- 30) x_771) - (* (- 24) x_776) - (* (- 30) x_781) - (* (- 24) x_786) - (* (- 30) x_791) - (* (- 36) x_796) - (* (- 42) x_801) - (* (- 48) x_806) - (* (- 54) x_811) - (* (- 60) x_816) - (* (- 24) x_821) - (* (- 30) x_826) - (* (- 36) x_831) - (* (- 42) x_836) - (* (- 48) x_841) - (* (- 54) x_846) - (* (- 60) x_851) - (* (- 66) x_856) - (* (- 24) x_861) - (* (- 30) x_866) - (* (- 36) x_871) - (* (- 42) x_876) - (* (- 48) x_881) - (* (- 54) x_886) - (* (- 24) x_891) - (* (- 30) x_896) - (* (- 36) x_901) - (* (- 42) x_906) - (* (- 48) x_911) - (* (- 54) x_916) - (* (- 60) x_921) - (* (- 36) x_926) - (* (- 36) x_931) - (* (- 45) x_936) - (* (- 36) x_941) - (* (- 36) x_946) - (* (- 45) x_951) - (* (- 36) x_956) - (* (- 45) x_961) - (* (- 36) x_966) - (* (- 45) x_971) - (* (- 54) x_976) - (* (- 63) x_981) - (* (- 72) x_986) - (* (- 81) x_991) - (* (- 90) x_996) - (* (- 24) x_1)))) -(assert (<= 0 - (+ (* 7700 x_1403) - (* (- 30) x_7) - (* (- 24) x_12) - (* (- 30) x_17) - (* (- 36) x_22) - (* (- 24) x_27) - (* (- 24) x_32) - (* (- 30) x_37) - (* (- 24) x_42) - (* (- 24) x_47) - (* (- 24) x_52) - (* (- 30) x_57) - (* (- 24) x_62) - (* (- 24) x_67) - (* (- 30) x_72) - (* (- 36) x_77) - (* (- 42) x_82) - (* (- 48) x_87) - (* (- 54) x_92) - (* (- 60) x_97) - (* (- 24) x_102) - (* (- 30) x_107) - (* (- 36) x_112) - (* (- 42) x_117) - (* (- 24) x_122) - (* (- 30) x_127) - (* (- 36) x_132) - (* (- 42) x_137) - (* (- 48) x_142) - (* (- 54) x_147) - (* (- 60) x_152) - (* (- 66) x_157) - (* (- 72) x_162) - (* (- 24) x_167) - (* (- 30) x_172) - (* (- 36) x_177) - (* (- 42) x_182) - (* (- 24) x_187) - (* (- 30) x_192) - (* (- 36) x_197) - (* (- 24) x_202) - (* (- 30) x_207) - (* (- 24) x_212) - (* (- 30) x_217) - (* (- 36) x_222) - (* (- 42) x_227) - (* (- 48) x_232) - (* (- 54) x_237) - (* (- 60) x_242) - (* (- 66) x_247) - (* (- 24) x_252) - (* (- 30) x_257) - (* (- 36) x_262) - (* (- 42) x_267) - (* (- 48) x_272) - (* (- 54) x_277) - (* (- 60) x_282) - (* (- 24) x_287) - (* (- 30) x_292) - (* (- 36) x_297) - (* (- 42) x_302) - (* (- 48) x_307) - (* (- 54) x_312) - (* (- 60) x_317) - (* (- 66) x_322) - (* (- 24) x_327) - (* (- 30) x_332) - (* (- 36) x_337) - (* (- 42) x_342) - (* (- 48) x_347) - (* (- 54) x_352) - (* (- 60) x_357) - (* (- 24) x_362) - (* (- 30) x_367) - (* (- 36) x_372) - (* (- 42) x_377) - (* (- 48) x_382) - (* (- 54) x_387) - (* (- 60) x_392) - (* (- 24) x_397) - (* (- 30) x_402) - (* (- 36) x_407) - (* (- 24) x_412) - (* (- 30) x_417) - (* (- 36) x_422) - (* (- 42) x_427) - (* (- 48) x_432) - (* (- 54) x_437) - (* (- 60) x_442) - (* (- 66) x_447) - (* (- 72) x_452) - (* (- 78) x_457) - (* (- 24) x_462) - (* (- 30) x_467) - (* (- 36) x_472) - (* (- 42) x_477) - (* (- 48) x_482) - (* (- 54) x_487) - (* (- 24) x_492) - (* (- 24) x_497) - (* (- 30) x_502) - (* (- 36) x_507) - (* (- 42) x_512) - (* (- 48) x_517) - (* (- 54) x_522) - (* (- 24) x_527) - (* (- 30) x_532) - (* (- 36) x_537) - (* (- 24) x_542) - (* (- 30) x_547) - (* (- 36) x_552) - (* (- 42) x_557) - (* (- 24) x_562) - (* (- 30) x_567) - (* (- 36) x_572) - (* (- 42) x_577) - (* (- 48) x_582) - (* (- 54) x_587) - (* (- 24) x_592) - (* (- 24) x_597) - (* (- 30) x_602) - (* (- 36) x_607) - (* (- 42) x_612) - (* (- 48) x_617) - (* (- 24) x_622) - (* (- 30) x_627) - (* (- 36) x_632) - (* (- 42) x_637) - (* (- 48) x_642) - (* (- 54) x_647) - (* (- 60) x_652) - (* (- 66) x_657) - (* (- 24) x_662) - (* (- 30) x_667) - (* (- 36) x_672) - (* (- 42) x_677) - (* (- 24) x_682) - (* (- 30) x_687) - (* (- 36) x_692) - (* (- 42) x_697) - (* (- 48) x_702) - (* (- 54) x_707) - (* (- 60) x_712) - (* (- 66) x_717) - (* (- 72) x_722) - (* (- 24) x_727) - (* (- 30) x_732) - (* (- 36) x_737) - (* (- 42) x_742) - (* (- 48) x_747) - (* (- 54) x_752) - (* (- 60) x_757) - (* (- 66) x_762) - (* (- 24) x_767) - (* (- 30) x_772) - (* (- 24) x_777) - (* (- 30) x_782) - (* (- 24) x_787) - (* (- 30) x_792) - (* (- 36) x_797) - (* (- 42) x_802) - (* (- 48) x_807) - (* (- 54) x_812) - (* (- 60) x_817) - (* (- 24) x_822) - (* (- 30) x_827) - (* (- 36) x_832) - (* (- 42) x_837) - (* (- 48) x_842) - (* (- 54) x_847) - (* (- 60) x_852) - (* (- 66) x_857) - (* (- 24) x_862) - (* (- 30) x_867) - (* (- 36) x_872) - (* (- 42) x_877) - (* (- 48) x_882) - (* (- 54) x_887) - (* (- 24) x_892) - (* (- 30) x_897) - (* (- 36) x_902) - (* (- 42) x_907) - (* (- 48) x_912) - (* (- 54) x_917) - (* (- 60) x_922) - (* (- 36) x_927) - (* (- 36) x_932) - (* (- 45) x_937) - (* (- 36) x_942) - (* (- 36) x_947) - (* (- 45) x_952) - (* (- 36) x_957) - (* (- 45) x_962) - (* (- 36) x_967) - (* (- 45) x_972) - (* (- 54) x_977) - (* (- 63) x_982) - (* (- 72) x_987) - (* (- 81) x_992) - (* (- 90) x_997) - (* (- 24) x_2)))) -(assert (<= 0 - (+ (* 3960 x_1604) - (* (- 30) x_8) - (* (- 24) x_13) - (* (- 30) x_18) - (* (- 36) x_23) - (* (- 24) x_28) - (* (- 24) x_33) - (* (- 30) x_38) - (* (- 24) x_43) - (* (- 24) x_48) - (* (- 24) x_53) - (* (- 30) x_58) - (* (- 24) x_63) - (* (- 24) x_68) - (* (- 30) x_73) - (* (- 36) x_78) - (* (- 42) x_83) - (* (- 48) x_88) - (* (- 54) x_93) - (* (- 60) x_98) - (* (- 24) x_103) - (* (- 30) x_108) - (* (- 36) x_113) - (* (- 42) x_118) - (* (- 24) x_123) - (* (- 30) x_128) - (* (- 36) x_133) - (* (- 42) x_138) - (* (- 48) x_143) - (* (- 54) x_148) - (* (- 60) x_153) - (* (- 66) x_158) - (* (- 72) x_163) - (* (- 24) x_168) - (* (- 30) x_173) - (* (- 36) x_178) - (* (- 42) x_183) - (* (- 24) x_188) - (* (- 30) x_193) - (* (- 36) x_198) - (* (- 24) x_203) - (* (- 30) x_208) - (* (- 24) x_213) - (* (- 30) x_218) - (* (- 36) x_223) - (* (- 42) x_228) - (* (- 48) x_233) - (* (- 54) x_238) - (* (- 60) x_243) - (* (- 66) x_248) - (* (- 24) x_253) - (* (- 30) x_258) - (* (- 36) x_263) - (* (- 42) x_268) - (* (- 48) x_273) - (* (- 54) x_278) - (* (- 60) x_283) - (* (- 24) x_288) - (* (- 30) x_293) - (* (- 36) x_298) - (* (- 42) x_303) - (* (- 48) x_308) - (* (- 54) x_313) - (* (- 60) x_318) - (* (- 66) x_323) - (* (- 24) x_328) - (* (- 30) x_333) - (* (- 36) x_338) - (* (- 42) x_343) - (* (- 48) x_348) - (* (- 54) x_353) - (* (- 60) x_358) - (* (- 24) x_363) - (* (- 30) x_368) - (* (- 36) x_373) - (* (- 42) x_378) - (* (- 48) x_383) - (* (- 54) x_388) - (* (- 60) x_393) - (* (- 24) x_398) - (* (- 30) x_403) - (* (- 36) x_408) - (* (- 24) x_413) - (* (- 30) x_418) - (* (- 36) x_423) - (* (- 42) x_428) - (* (- 48) x_433) - (* (- 54) x_438) - (* (- 60) x_443) - (* (- 66) x_448) - (* (- 72) x_453) - (* (- 78) x_458) - (* (- 24) x_463) - (* (- 30) x_468) - (* (- 36) x_473) - (* (- 42) x_478) - (* (- 48) x_483) - (* (- 54) x_488) - (* (- 24) x_493) - (* (- 24) x_498) - (* (- 30) x_503) - (* (- 36) x_508) - (* (- 42) x_513) - (* (- 48) x_518) - (* (- 54) x_523) - (* (- 24) x_528) - (* (- 30) x_533) - (* (- 36) x_538) - (* (- 24) x_543) - (* (- 30) x_548) - (* (- 36) x_553) - (* (- 42) x_558) - (* (- 24) x_563) - (* (- 30) x_568) - (* (- 36) x_573) - (* (- 42) x_578) - (* (- 48) x_583) - (* (- 54) x_588) - (* (- 24) x_593) - (* (- 24) x_598) - (* (- 30) x_603) - (* (- 36) x_608) - (* (- 42) x_613) - (* (- 48) x_618) - (* (- 24) x_623) - (* (- 30) x_628) - (* (- 36) x_633) - (* (- 42) x_638) - (* (- 48) x_643) - (* (- 54) x_648) - (* (- 60) x_653) - (* (- 66) x_658) - (* (- 24) x_663) - (* (- 30) x_668) - (* (- 36) x_673) - (* (- 42) x_678) - (* (- 24) x_683) - (* (- 30) x_688) - (* (- 36) x_693) - (* (- 42) x_698) - (* (- 48) x_703) - (* (- 54) x_708) - (* (- 60) x_713) - (* (- 66) x_718) - (* (- 72) x_723) - (* (- 24) x_728) - (* (- 30) x_733) - (* (- 36) x_738) - (* (- 42) x_743) - (* (- 48) x_748) - (* (- 54) x_753) - (* (- 60) x_758) - (* (- 66) x_763) - (* (- 24) x_768) - (* (- 30) x_773) - (* (- 24) x_778) - (* (- 30) x_783) - (* (- 24) x_788) - (* (- 30) x_793) - (* (- 36) x_798) - (* (- 42) x_803) - (* (- 48) x_808) - (* (- 54) x_813) - (* (- 60) x_818) - (* (- 24) x_823) - (* (- 30) x_828) - (* (- 36) x_833) - (* (- 42) x_838) - (* (- 48) x_843) - (* (- 54) x_848) - (* (- 60) x_853) - (* (- 66) x_858) - (* (- 24) x_863) - (* (- 30) x_868) - (* (- 36) x_873) - (* (- 42) x_878) - (* (- 48) x_883) - (* (- 54) x_888) - (* (- 24) x_893) - (* (- 30) x_898) - (* (- 36) x_903) - (* (- 42) x_908) - (* (- 48) x_913) - (* (- 54) x_918) - (* (- 60) x_923) - (* (- 36) x_928) - (* (- 36) x_933) - (* (- 45) x_938) - (* (- 36) x_943) - (* (- 36) x_948) - (* (- 45) x_953) - (* (- 36) x_958) - (* (- 45) x_963) - (* (- 36) x_968) - (* (- 45) x_973) - (* (- 54) x_978) - (* (- 63) x_983) - (* (- 72) x_988) - (* (- 81) x_993) - (* (- 90) x_998) - (* (- 24) x_3)))) - -(assert (= x_1202 1)) -(assert (= x_1403 1)) -(assert (= x_1604 0)) -(assert (= x_1001 0)) - -;(minimize (+ x_1202 x_1403 x_1604 x_1001)) -(minimize (+ (* 2 x_1) - (* 3 x_2) - (* 4 x_3) - x_9 - (* 2 x_6) - (* 3 x_7) - (* 4 x_8) - x_14 - (* 2 x_11) - (* 3 x_12) - (* 4 x_13) - x_19 - (* 2 x_16) - (* 3 x_17) - (* 4 x_18) - x_24 - (* 2 x_21) - (* 3 x_22) - (* 4 x_23) - x_29 - (* 2 x_26) - (* 3 x_27) - (* 4 x_28) - x_34 - (* 2 x_31) - (* 3 x_32) - (* 4 x_33) - x_39 - (* 2 x_36) - (* 3 x_37) - (* 4 x_38) - x_44 - (* 2 x_41) - (* 3 x_42) - (* 4 x_43) - x_49 - (* 2 x_46) - (* 3 x_47) - (* 4 x_48) - x_54 - (* 2 x_51) - (* 3 x_52) - (* 4 x_53) - x_59 - (* 2 x_56) - (* 3 x_57) - (* 4 x_58) - x_64 - (* 2 x_61) - (* 3 x_62) - (* 4 x_63) - x_69 - (* 2 x_66) - (* 3 x_67) - (* 4 x_68) - x_74 - (* 2 x_71) - (* 3 x_72) - (* 4 x_73) - x_79 - (* 2 x_76) - (* 3 x_77) - (* 4 x_78) - x_84 - (* 2 x_81) - (* 3 x_82) - (* 4 x_83) - x_89 - (* 2 x_86) - (* 3 x_87) - (* 4 x_88) - x_94 - (* 2 x_91) - (* 3 x_92) - (* 4 x_93) - x_99 - (* 2 x_96) - (* 3 x_97) - (* 4 x_98) - x_104 - (* 2 x_101) - (* 3 x_102) - (* 4 x_103) - x_109 - (* 2 x_106) - (* 3 x_107) - (* 4 x_108) - x_114 - (* 2 x_111) - (* 3 x_112) - (* 4 x_113) - x_119 - (* 2 x_116) - (* 3 x_117) - (* 4 x_118) - x_124 - (* 2 x_121) - (* 3 x_122) - (* 4 x_123) - x_129 - (* 2 x_126) - (* 3 x_127) - (* 4 x_128) - x_134 - (* 2 x_131) - (* 3 x_132) - (* 4 x_133) - x_139 - (* 2 x_136) - (* 3 x_137) - (* 4 x_138) - x_144 - (* 2 x_141) - (* 3 x_142) - (* 4 x_143) - x_149 - (* 2 x_146) - (* 3 x_147) - (* 4 x_148) - x_154 - (* 2 x_151) - (* 3 x_152) - (* 4 x_153) - x_159 - (* 2 x_156) - (* 3 x_157) - (* 4 x_158) - x_164 - (* 2 x_161) - (* 3 x_162) - (* 4 x_163) - x_169 - (* 2 x_166) - (* 3 x_167) - (* 4 x_168) - x_174 - (* 2 x_171) - (* 3 x_172) - (* 4 x_173) - x_179 - (* 2 x_176) - (* 3 x_177) - (* 4 x_178) - x_184 - (* 2 x_181) - (* 3 x_182) - (* 4 x_183) - x_189 - (* 2 x_186) - (* 3 x_187) - (* 4 x_188) - x_194 - (* 2 x_191) - (* 3 x_192) - (* 4 x_193) - x_199 - (* 2 x_196) - (* 3 x_197) - (* 4 x_198) - x_204 - (* 2 x_201) - (* 3 x_202) - (* 4 x_203) - x_209 - (* 2 x_206) - (* 3 x_207) - (* 4 x_208) - x_214 - (* 2 x_211) - (* 3 x_212) - (* 4 x_213) - x_219 - (* 2 x_216) - (* 3 x_217) - (* 4 x_218) - x_224 - (* 2 x_221) - (* 3 x_222) - (* 4 x_223) - x_229 - (* 2 x_226) - (* 3 x_227) - (* 4 x_228) - x_234 - (* 2 x_231) - (* 3 x_232) - (* 4 x_233) - x_239 - (* 2 x_236) - (* 3 x_237) - (* 4 x_238) - x_244 - (* 2 x_241) - (* 3 x_242) - (* 4 x_243) - x_249 - (* 2 x_246) - (* 3 x_247) - (* 4 x_248) - x_254 - (* 2 x_251) - (* 3 x_252) - (* 4 x_253) - x_259 - (* 2 x_256) - (* 3 x_257) - (* 4 x_258) - x_264 - (* 2 x_261) - (* 3 x_262) - (* 4 x_263) - x_269 - (* 2 x_266) - (* 3 x_267) - (* 4 x_268) - x_274 - (* 2 x_271) - (* 3 x_272) - (* 4 x_273) - x_279 - (* 2 x_276) - (* 3 x_277) - (* 4 x_278) - x_284 - (* 2 x_281) - (* 3 x_282) - (* 4 x_283) - x_289 - (* 2 x_286) - (* 3 x_287) - (* 4 x_288) - x_294 - (* 2 x_291) - (* 3 x_292) - (* 4 x_293) - x_299 - (* 2 x_296) - (* 3 x_297) - (* 4 x_298) - x_304 - (* 2 x_301) - (* 3 x_302) - (* 4 x_303) - x_309 - (* 2 x_306) - (* 3 x_307) - (* 4 x_308) - x_314 - (* 2 x_311) - (* 3 x_312) - (* 4 x_313) - x_319 - (* 2 x_316) - (* 3 x_317) - (* 4 x_318) - x_324 - (* 2 x_321) - (* 3 x_322) - (* 4 x_323) - x_329 - (* 2 x_326) - (* 3 x_327) - (* 4 x_328) - x_334 - (* 2 x_331) - (* 3 x_332) - (* 4 x_333) - x_339 - (* 2 x_336) - (* 3 x_337) - (* 4 x_338) - x_344 - (* 2 x_341) - (* 3 x_342) - (* 4 x_343) - x_349 - (* 2 x_346) - (* 3 x_347) - (* 4 x_348) - x_354 - (* 2 x_351) - (* 3 x_352) - (* 4 x_353) - x_359 - (* 2 x_356) - (* 3 x_357) - (* 4 x_358) - x_364 - (* 2 x_361) - (* 3 x_362) - (* 4 x_363) - x_369 - (* 2 x_366) - (* 3 x_367) - (* 4 x_368) - x_374 - (* 2 x_371) - (* 3 x_372) - (* 4 x_373) - x_379 - (* 2 x_376) - (* 3 x_377) - (* 4 x_378) - x_384 - (* 2 x_381) - (* 3 x_382) - (* 4 x_383) - x_389 - (* 2 x_386) - (* 3 x_387) - (* 4 x_388) - x_394 - (* 2 x_391) - (* 3 x_392) - (* 4 x_393) - x_399 - (* 2 x_396) - (* 3 x_397) - (* 4 x_398) - x_404 - (* 2 x_401) - (* 3 x_402) - (* 4 x_403) - x_409 - (* 2 x_406) - (* 3 x_407) - (* 4 x_408) - x_414 - (* 2 x_411) - (* 3 x_412) - (* 4 x_413) - x_419 - (* 2 x_416) - (* 3 x_417) - (* 4 x_418) - x_424 - (* 2 x_421) - (* 3 x_422) - (* 4 x_423) - x_429 - (* 2 x_426) - (* 3 x_427) - (* 4 x_428) - x_434 - (* 2 x_431) - (* 3 x_432) - (* 4 x_433) - x_439 - (* 2 x_436) - (* 3 x_437) - (* 4 x_438) - x_444 - (* 2 x_441) - (* 3 x_442) - (* 4 x_443) - x_449 - (* 2 x_446) - (* 3 x_447) - (* 4 x_448) - x_454 - (* 2 x_451) - (* 3 x_452) - (* 4 x_453) - x_459 - (* 2 x_456) - (* 3 x_457) - (* 4 x_458) - x_464 - (* 2 x_461) - (* 3 x_462) - (* 4 x_463) - x_469 - (* 2 x_466) - (* 3 x_467) - (* 4 x_468) - x_474 - (* 2 x_471) - (* 3 x_472) - (* 4 x_473) - x_479 - (* 2 x_476) - (* 3 x_477) - (* 4 x_478) - x_484 - (* 2 x_481) - (* 3 x_482) - (* 4 x_483) - x_489 - (* 2 x_486) - (* 3 x_487) - (* 4 x_488) - x_494 - (* 2 x_491) - (* 3 x_492) - (* 4 x_493) - x_499 - (* 2 x_496) - (* 3 x_497) - (* 4 x_498) - x_504 - (* 2 x_501) - (* 3 x_502) - (* 4 x_503) - x_509 - (* 2 x_506) - (* 3 x_507) - (* 4 x_508) - x_514 - (* 2 x_511) - (* 3 x_512) - (* 4 x_513) - x_519 - (* 2 x_516) - (* 3 x_517) - (* 4 x_518) - x_524 - (* 2 x_521) - (* 3 x_522) - (* 4 x_523) - x_529 - (* 2 x_526) - (* 3 x_527) - (* 4 x_528) - x_534 - (* 2 x_531) - (* 3 x_532) - (* 4 x_533) - x_539 - (* 2 x_536) - (* 3 x_537) - (* 4 x_538) - x_544 - (* 2 x_541) - (* 3 x_542) - (* 4 x_543) - x_549 - (* 2 x_546) - (* 3 x_547) - (* 4 x_548) - x_554 - (* 2 x_551) - (* 3 x_552) - (* 4 x_553) - x_559 - (* 2 x_556) - (* 3 x_557) - (* 4 x_558) - x_564 - (* 2 x_561) - (* 3 x_562) - (* 4 x_563) - x_569 - (* 2 x_566) - (* 3 x_567) - (* 4 x_568) - x_574 - (* 2 x_571) - (* 3 x_572) - (* 4 x_573) - x_579 - (* 2 x_576) - (* 3 x_577) - (* 4 x_578) - x_584 - (* 2 x_581) - (* 3 x_582) - (* 4 x_583) - x_589 - (* 2 x_586) - (* 3 x_587) - (* 4 x_588) - x_594 - (* 2 x_591) - (* 3 x_592) - (* 4 x_593) - x_599 - (* 2 x_596) - (* 3 x_597) - (* 4 x_598) - x_604 - (* 2 x_601) - (* 3 x_602) - (* 4 x_603) - x_609 - (* 2 x_606) - (* 3 x_607) - (* 4 x_608) - x_614 - (* 2 x_611) - (* 3 x_612) - (* 4 x_613) - x_619 - (* 2 x_616) - (* 3 x_617) - (* 4 x_618) - x_624 - (* 2 x_621) - (* 3 x_622) - (* 4 x_623) - x_629 - (* 2 x_626) - (* 3 x_627) - (* 4 x_628) - x_634 - (* 2 x_631) - (* 3 x_632) - (* 4 x_633) - x_639 - (* 2 x_636) - (* 3 x_637) - (* 4 x_638) - x_644 - (* 2 x_641) - (* 3 x_642) - (* 4 x_643) - x_649 - (* 2 x_646) - (* 3 x_647) - (* 4 x_648) - x_654 - (* 2 x_651) - (* 3 x_652) - (* 4 x_653) - x_659 - (* 2 x_656) - (* 3 x_657) - (* 4 x_658) - x_664 - (* 2 x_661) - (* 3 x_662) - (* 4 x_663) - x_669 - (* 2 x_666) - (* 3 x_667) - (* 4 x_668) - x_674 - (* 2 x_671) - (* 3 x_672) - (* 4 x_673) - x_679 - (* 2 x_676) - (* 3 x_677) - (* 4 x_678) - x_684 - (* 2 x_681) - (* 3 x_682) - (* 4 x_683) - x_689 - (* 2 x_686) - (* 3 x_687) - (* 4 x_688) - x_694 - (* 2 x_691) - (* 3 x_692) - (* 4 x_693) - x_699 - (* 2 x_696) - (* 3 x_697) - (* 4 x_698) - x_704 - (* 2 x_701) - (* 3 x_702) - (* 4 x_703) - x_709 - (* 2 x_706) - (* 3 x_707) - (* 4 x_708) - x_714 - (* 2 x_711) - (* 3 x_712) - (* 4 x_713) - x_719 - (* 2 x_716) - (* 3 x_717) - (* 4 x_718) - x_724 - (* 2 x_721) - (* 3 x_722) - (* 4 x_723) - x_729 - (* 2 x_726) - (* 3 x_727) - (* 4 x_728) - x_734 - (* 2 x_731) - (* 3 x_732) - (* 4 x_733) - x_739 - (* 2 x_736) - (* 3 x_737) - (* 4 x_738) - x_744 - (* 2 x_741) - (* 3 x_742) - (* 4 x_743) - x_749 - (* 2 x_746) - (* 3 x_747) - (* 4 x_748) - x_754 - (* 2 x_751) - (* 3 x_752) - (* 4 x_753) - x_759 - (* 2 x_756) - (* 3 x_757) - (* 4 x_758) - x_764 - (* 2 x_761) - (* 3 x_762) - (* 4 x_763) - x_769 - (* 2 x_766) - (* 3 x_767) - (* 4 x_768) - x_774 - (* 2 x_771) - (* 3 x_772) - (* 4 x_773) - x_779 - (* 2 x_776) - (* 3 x_777) - (* 4 x_778) - x_784 - (* 2 x_781) - (* 3 x_782) - (* 4 x_783) - x_789 - (* 2 x_786) - (* 3 x_787) - (* 4 x_788) - x_794 - (* 2 x_791) - (* 3 x_792) - (* 4 x_793) - x_799 - (* 2 x_796) - (* 3 x_797) - (* 4 x_798) - x_804 - (* 2 x_801) - (* 3 x_802) - (* 4 x_803) - x_809 - (* 2 x_806) - (* 3 x_807) - (* 4 x_808) - x_814 - (* 2 x_811) - (* 3 x_812) - (* 4 x_813) - x_819 - (* 2 x_816) - (* 3 x_817) - (* 4 x_818) - x_824 - (* 2 x_821) - (* 3 x_822) - (* 4 x_823) - x_829 - (* 2 x_826) - (* 3 x_827) - (* 4 x_828) - x_834 - (* 2 x_831) - (* 3 x_832) - (* 4 x_833) - x_839 - (* 2 x_836) - (* 3 x_837) - (* 4 x_838) - x_844 - (* 2 x_841) - (* 3 x_842) - (* 4 x_843) - x_849 - (* 2 x_846) - (* 3 x_847) - (* 4 x_848) - x_854 - (* 2 x_851) - (* 3 x_852) - (* 4 x_853) - x_859 - (* 2 x_856) - (* 3 x_857) - (* 4 x_858) - x_864 - (* 2 x_861) - (* 3 x_862) - (* 4 x_863) - x_869 - (* 2 x_866) - (* 3 x_867) - (* 4 x_868) - x_874 - (* 2 x_871) - (* 3 x_872) - (* 4 x_873) - x_879 - (* 2 x_876) - (* 3 x_877) - (* 4 x_878) - x_884 - (* 2 x_881) - (* 3 x_882) - (* 4 x_883) - x_889 - (* 2 x_886) - (* 3 x_887) - (* 4 x_888) - x_894 - (* 2 x_891) - (* 3 x_892) - (* 4 x_893) - x_899 - (* 2 x_896) - (* 3 x_897) - (* 4 x_898) - x_904 - (* 2 x_901) - (* 3 x_902) - (* 4 x_903) - x_909 - (* 2 x_906) - (* 3 x_907) - (* 4 x_908) - x_914 - (* 2 x_911) - (* 3 x_912) - (* 4 x_913) - x_919 - (* 2 x_916) - (* 3 x_917) - (* 4 x_918) - x_924 - (* 2 x_921) - (* 3 x_922) - (* 4 x_923) - x_929 - (* 2 x_926) - (* 3 x_927) - (* 4 x_928) - x_934 - (* 2 x_931) - (* 3 x_932) - (* 4 x_933) - x_939 - (* 2 x_936) - (* 3 x_937) - (* 4 x_938) - x_944 - (* 2 x_941) - (* 3 x_942) - (* 4 x_943) - x_949 - (* 2 x_946) - (* 3 x_947) - (* 4 x_948) - x_954 - (* 2 x_951) - (* 3 x_952) - (* 4 x_953) - x_959 - (* 2 x_956) - (* 3 x_957) - (* 4 x_958) - x_964 - (* 2 x_961) - (* 3 x_962) - (* 4 x_963) - x_969 - (* 2 x_966) - (* 3 x_967) - (* 4 x_968) - x_974 - (* 2 x_971) - (* 3 x_972) - (* 4 x_973) - x_979 - (* 2 x_976) - (* 3 x_977) - (* 4 x_978) - x_984 - (* 2 x_981) - (* 3 x_982) - (* 4 x_983) - x_989 - (* 2 x_986) - (* 3 x_987) - (* 4 x_988) - x_994 - (* 2 x_991) - (* 3 x_992) - (* 4 x_993) - x_999 - (* 2 x_996) - (* 3 x_997) - (* 4 x_998) - x_4 - (* 100 x_1202) - (* 100 x_1403) - (* 100 x_1604) - (* 100 x_1001))) -(optimize :print_statistics true - :wmaxsat_engine bvsls - :maxsat_engine weighted_maxsat) diff --git a/tests/wmax1.smt2 b/tests/wmax1.smt2 deleted file mode 100644 index 602309e952e..00000000000 --- a/tests/wmax1.smt2 +++ /dev/null @@ -1,5842 +0,0 @@ -(declare-fun x_354 () Int) -(declare-fun x_522 () Int) -(declare-fun x_464 () Int) -(declare-fun x_644 () Int) -(declare-fun x_174 () Int) -(declare-fun x_397 () Int) -(declare-fun x_432 () Int) -(declare-fun x_557 () Int) -(declare-fun x_926 () Int) -(declare-fun x_582 () Int) -(declare-fun x_779 () Int) -(declare-fun x_759 () Int) -(declare-fun x_912 () Int) -(declare-fun x_868 () Int) -(declare-fun x_384 () Int) -(declare-fun x_963 () Int) -(declare-fun x_658 () Int) -(declare-fun x_362 () Int) -(declare-fun x_984 () Int) -(declare-fun x_308 () Int) -(declare-fun x_456 () Int) -(declare-fun x_17 () Int) -(declare-fun x_816 () Int) -(declare-fun x_833 () Int) -(declare-fun x_463 () Int) -(declare-fun x_211 () Int) -(declare-fun x_607 () Int) -(declare-fun x_139 () Int) -(declare-fun x_124 () Int) -(declare-fun x_291 () Int) -(declare-fun x_859 () Int) -(declare-fun x_888 () Int) -(declare-fun x_31 () Int) -(declare-fun x_472 () Int) -(declare-fun x_434 () Int) -(declare-fun x_154 () Int) -(declare-fun x_347 () Int) -(declare-fun x_88 () Int) -(declare-fun x_769 () Int) -(declare-fun x_986 () Int) -(declare-fun x_8 () Int) -(declare-fun x_196 () Int) -(declare-fun x_882 () Int) -(declare-fun x_711 () Int) -(declare-fun x_167 () Int) -(declare-fun x_119 () Int) -(declare-fun x_4 () Int) -(declare-fun x_33 () Int) -(declare-fun x_178 () Int) -(declare-fun x_893 () Int) -(declare-fun x_429 () Int) -(declare-fun x_527 () Int) -(declare-fun x_194 () Int) -(declare-fun x_498 () Int) -(declare-fun x_346 () Int) -(declare-fun x_712 () Int) -(declare-fun x_691 () Int) -(declare-fun x_294 () Int) -(declare-fun x_402 () Int) -(declare-fun x_213 () Int) -(declare-fun x_239 () Int) -(declare-fun x_297 () Int) -(declare-fun x_427 () Int) -(declare-fun x_489 () Int) -(declare-fun x_841 () Int) -(declare-fun x_186 () Int) -(declare-fun x_149 () Int) -(declare-fun x_586 () Int) -(declare-fun x_932 () Int) -(declare-fun x_367 () Int) -(declare-fun x_77 () Int) -(declare-fun x_123 () Int) -(declare-fun x_884 () Int) -(declare-fun x_989 () Int) -(declare-fun x_242 () Int) -(declare-fun x_614 () Int) -(declare-fun x_381 () Int) -(declare-fun x_388 () Int) -(declare-fun x_306 () Int) -(declare-fun x_737 () Int) -(declare-fun x_277 () Int) -(declare-fun x_966 () Int) -(declare-fun x_67 () Int) -(declare-fun x_678 () Int) -(declare-fun x_87 () Int) -(declare-fun x_496 () Int) -(declare-fun x_919 () Int) -(declare-fun x_439 () Int) -(declare-fun x_854 () Int) -(declare-fun x_961 () Int) -(declare-fun x_697 () Int) -(declare-fun x_19 () Int) -(declare-fun x_818 () Int) -(declare-fun x_158 () Int) -(declare-fun x_26 () Int) -(declare-fun x_436 () Int) -(declare-fun x_798 () Int) -(declare-fun x_457 () Int) -(declare-fun x_838 () Int) -(declare-fun x_953 () Int) -(declare-fun x_524 () Int) -(declare-fun x_574 () Int) -(declare-fun x_212 () Int) -(declare-fun x_486 () Int) -(declare-fun x_3 () Int) -(declare-fun x_256 () Int) -(declare-fun x_22 () Int) -(declare-fun x_676 () Int) -(declare-fun x_789 () Int) -(declare-fun x_892 () Int) -(declare-fun x_682 () Int) -(declare-fun x_84 () Int) -(declare-fun x_819 () Int) -(declare-fun x_454 () Int) -(declare-fun x_59 () Int) -(declare-fun x_227 () Int) -(declare-fun x_572 () Int) -(declare-fun x_914 () Int) -(declare-fun x_39 () Int) -(declare-fun x_679 () Int) -(declare-fun x_824 () Int) -(declare-fun x_684 () Int) -(declare-fun x_221 () Int) -(declare-fun x_274 () Int) -(declare-fun x_32 () Int) -(declare-fun x_348 () Int) -(declare-fun x_877 () Int) -(declare-fun x_701 () Int) -(declare-fun x_231 () Int) -(declare-fun x_549 () Int) -(declare-fun x_889 () Int) -(declare-fun x_879 () Int) -(declare-fun x_662 () Int) -(declare-fun x_302 () Int) -(declare-fun x_979 () Int) -(declare-fun x_861 () Int) -(declare-fun x_973 () Int) -(declare-fun x_401 () Int) -(declare-fun x_537 () Int) -(declare-fun x_972 () Int) -(declare-fun x_269 () Int) -(declare-fun x_957 () Int) -(declare-fun x_271 () Int) -(declare-fun x_363 () Int) -(declare-fun x_181 () Int) -(declare-fun x_357 () Int) -(declare-fun x_591 () Int) -(declare-fun x_559 () Int) -(declare-fun x_51 () Int) -(declare-fun x_916 () Int) -(declare-fun x_389 () Int) -(declare-fun x_512 () Int) -(declare-fun x_988 () Int) -(declare-fun x_667 () Int) -(declare-fun x_511 () Int) -(declare-fun x_733 () Int) -(declare-fun x_821 () Int) -(declare-fun x_671 () Int) -(declare-fun x_707 () Int) -(declare-fun x_826 () Int) -(declare-fun x_319 () Int) -(declare-fun x_399 () Int) -(declare-fun x_852 () Int) -(declare-fun x_442 () Int) -(declare-fun x_108 () Int) -(declare-fun x_392 () Int) -(declare-fun x_776 () Int) -(declare-fun x_993 () Int) -(declare-fun x_459 () Int) -(declare-fun x_913 () Int) -(declare-fun x_107 () Int) -(declare-fun x_994 () Int) -(declare-fun x_61 () Int) -(declare-fun x_802 () Int) -(declare-fun x_677 () Int) -(declare-fun x_857 () Int) -(declare-fun x_706 () Int) -(declare-fun x_278 () Int) -(declare-fun x_443 () Int) -(declare-fun x_813 () Int) -(declare-fun x_971 () Int) -(declare-fun x_173 () Int) -(declare-fun x_91 () Int) -(declare-fun x_396 () Int) -(declare-fun x_551 () Int) -(declare-fun x_846 () Int) -(declare-fun x_417 () Int) -(declare-fun x_54 () Int) -(declare-fun x_721 () Int) -(declare-fun x_331 () Int) -(declare-fun x_467 () Int) -(declare-fun x_553 () Int) -(declare-fun x_959 () Int) -(declare-fun x_871 () Int) -(declare-fun x_692 () Int) -(declare-fun x_792 () Int) -(declare-fun x_593 () Int) -(declare-fun x_412 () Int) -(declare-fun x_531 () Int) -(declare-fun x_352 () Int) -(declare-fun x_333 () Int) -(declare-fun x_596 () Int) -(declare-fun x_229 () Int) -(declare-fun x_447 () Int) -(declare-fun x_53 () Int) -(declare-fun x_548 () Int) -(declare-fun x_43 () Int) -(declare-fun x_13 () Int) -(declare-fun x_198 () Int) -(declare-fun x_47 () Int) -(declare-fun x_626 () Int) -(declare-fun x_648 () Int) -(declare-fun x_902 () Int) -(declare-fun x_594 () Int) -(declare-fun x_113 () Int) -(declare-fun x_286 () Int) -(declare-fun x_163 () Int) -(declare-fun x_157 () Int) -(declare-fun x_659 () Int) -(declare-fun x_24 () Int) -(declare-fun x_631 () Int) -(declare-fun x_699 () Int) -(declare-fun x_366 () Int) -(declare-fun x_6 () Int) -(declare-fun x_156 () Int) -(declare-fun x_876 () Int) -(declare-fun x_598 () Int) -(declare-fun x_974 () Int) -(declare-fun x_372 () Int) -(declare-fun x_538 () Int) -(declare-fun x_287 () Int) -(declare-fun x_71 () Int) -(declare-fun x_371 () Int) -(declare-fun x_646 () Int) -(declare-fun x_519 () Int) -(declare-fun x_121 () Int) -(declare-fun x_268 () Int) -(declare-fun x_746 () Int) -(declare-fun x_562 () Int) -(declare-fun x_799 () Int) -(declare-fun x_423 () Int) -(declare-fun x_808 () Int) -(declare-fun x_303 () Int) -(declare-fun x_536 () Int) -(declare-fun x_344 () Int) -(declare-fun x_322 () Int) -(declare-fun x_299 () Int) -(declare-fun x_976 () Int) -(declare-fun x_279 () Int) -(declare-fun x_482 () Int) -(declare-fun x_246 () Int) -(declare-fun x_763 () Int) -(declare-fun x_111 () Int) -(declare-fun x_226 () Int) -(declare-fun x_741 () Int) -(declare-fun x_188 () Int) -(declare-fun x_873 () Int) -(declare-fun x_767 () Int) -(declare-fun x_766 () Int) -(declare-fun x_7 () Int) -(declare-fun x_377 () Int) -(declare-fun x_719 () Int) -(declare-fun x_704 () Int) -(declare-fun x_72 () Int) -(declare-fun x_27 () Int) -(declare-fun x_284 () Int) -(declare-fun x_943 () Int) -(declare-fun x_42 () Int) -(declare-fun x_881 () Int) -(declare-fun x_693 () Int) -(declare-fun x_422 () Int) -(declare-fun x_218 () Int) -(declare-fun x_736 () Int) -(declare-fun x_817 () Int) -(declare-fun x_168 () Int) -(declare-fun x_359 () Int) -(declare-fun x_16 () Int) -(declare-fun x_469 () Int) -(declare-fun x_814 () Int) -(declare-fun x_62 () Int) -(declare-fun x_461 () Int) -(declare-fun x_483 () Int) -(declare-fun x_68 () Int) -(declare-fun x_786 () Int) -(declare-fun x_938 () Int) -(declare-fun x_204 () Int) -(declare-fun x_718 () Int) -(declare-fun x_197 () Int) -(declare-fun x_603 () Int) -(declare-fun x_616 () Int) -(declare-fun x_117 () Int) -(declare-fun x_567 () Int) -(declare-fun x_729 () Int) -(declare-fun x_942 () Int) -(declare-fun x_748 () Int) -(declare-fun x_992 () Int) -(declare-fun x_713 () Int) -(declare-fun x_326 () Int) -(declare-fun x_689 () Int) -(declare-fun x_948 () Int) -(declare-fun x_717 () Int) -(declare-fun x_403 () Int) -(declare-fun x_872 () Int) -(declare-fun x_73 () Int) -(declare-fun x_639 () Int) -(declare-fun x_137 () Int) -(declare-fun x_373 () Int) -(declare-fun x_364 () Int) -(declare-fun x_576 () Int) -(declare-fun x_358 () Int) -(declare-fun x_466 () Int) -(declare-fun x_122 () Int) -(declare-fun x_637 () Int) -(declare-fun x_202 () Int) -(declare-fun x_476 () Int) -(declare-fun x_44 () Int) -(declare-fun x_151 () Int) -(declare-fun x_253 () Int) -(declare-fun x_696 () Int) -(declare-fun x_822 () Int) -(declare-fun x_641 () Int) -(declare-fun x_924 () Int) -(declare-fun x_233 () Int) -(declare-fun x_136 () Int) -(declare-fun x_222 () Int) -(declare-fun x_318 () Int) -(declare-fun x_694 () Int) -(declare-fun x_543 () Int) -(declare-fun x_141 () Int) -(declare-fun x_418 () Int) -(declare-fun x_409 () Int) -(declare-fun x_601 () Int) -(declare-fun x_339 () Int) -(declare-fun x_958 () Int) -(declare-fun x_773 () Int) -(declare-fun x_448 () Int) -(declare-fun x_508 () Int) -(declare-fun x_104 () Int) -(declare-fun x_674 () Int) -(declare-fun x_991 () Int) -(declare-fun x_406 () Int) -(declare-fun x_283 () Int) -(declare-fun x_552 () Int) -(declare-fun x_907 () Int) -(declare-fun x_408 () Int) -(declare-fun x_451 () Int) -(declare-fun x_897 () Int) -(declare-fun x_503 () Int) -(declare-fun x_672 () Int) -(declare-fun x_264 () Int) -(declare-fun x_382 () Int) -(declare-fun x_554 () Int) -(declare-fun x_561 () Int) -(declare-fun x_11 () Int) -(declare-fun x_329 () Int) -(declare-fun x_727 () Int) -(declare-fun x_97 () Int) -(declare-fun x_343 () Int) -(declare-fun x_918 () Int) -(declare-fun x_289 () Int) -(declare-fun x_803 () Int) -(declare-fun x_812 () Int) -(declare-fun x_547 () Int) -(declare-fun x_806 () Int) -(declare-fun x_252 () Int) -(declare-fun x_273 () Int) -(declare-fun x_618 () Int) -(declare-fun x_301 () Int) -(declare-fun x_688 () Int) -(declare-fun x_224 () Int) -(declare-fun x_449 () Int) -(declare-fun x_327 () Int) -(declare-fun x_387 () Int) -(declare-fun x_86 () Int) -(declare-fun x_89 () Int) -(declare-fun x_404 () Int) -(declare-fun x_507 () Int) -(declare-fun x_312 () Int) -(declare-fun x_578 () Int) -(declare-fun x_722 () Int) -(declare-fun x_762 () Int) -(declare-fun x_169 () Int) -(declare-fun x_206 () Int) -(declare-fun x_383 () Int) -(declare-fun x_867 () Int) -(declare-fun x_627 () Int) -(declare-fun x_638 () Int) -(declare-fun x_184 () Int) -(declare-fun x_479 () Int) -(declare-fun x_292 () Int) -(declare-fun x_844 () Int) -(declare-fun x_421 () Int) -(declare-fun x_911 () Int) -(declare-fun x_419 () Int) -(declare-fun x_612 () Int) -(declare-fun x_192 () Int) -(declare-fun x_656 () Int) -(declare-fun x_702 () Int) -(declare-fun x_778 () Int) -(declare-fun x_281 () Int) -(declare-fun x_834 () Int) -(declare-fun x_63 () Int) -(declare-fun x_836 () Int) -(declare-fun x_793 () Int) -(declare-fun x_622 () Int) -(declare-fun x_899 () Int) -(declare-fun x_944 () Int) -(declare-fun x_369 () Int) -(declare-fun x_336 () Int) -(declare-fun x_869 () Int) -(declare-fun x_257 () Int) -(declare-fun x_1001 () Int) -(declare-fun x_904 () Int) -(declare-fun x_528 () Int) -(declare-fun x_997 () Int) -(declare-fun x_414 () Int) -(declare-fun x_223 () Int) -(declare-fun x_642 () Int) -(declare-fun x_76 () Int) -(declare-fun x_29 () Int) -(declare-fun x_533 () Int) -(declare-fun x_41 () Int) -(declare-fun x_581 () Int) -(declare-fun x_791 () Int) -(declare-fun x_809 () Int) -(declare-fun x_321 () Int) -(declare-fun x_939 () Int) -(declare-fun x_541 () Int) -(declare-fun x_652 () Int) -(declare-fun x_569 () Int) -(declare-fun x_934 () Int) -(declare-fun x_207 () Int) -(declare-fun x_376 () Int) -(declare-fun x_109 () Int) -(declare-fun x_761 () Int) -(declare-fun x_446 () Int) -(declare-fun x_657 () Int) -(declare-fun x_171 () Int) -(declare-fun x_558 () Int) -(declare-fun x_276 () Int) -(declare-fun x_46 () Int) -(declare-fun x_668 () Int) -(declare-fun x_57 () Int) -(declare-fun x_374 () Int) -(declare-fun x_209 () Int) -(declare-fun x_739 () Int) -(declare-fun x_909 () Int) -(declare-fun x_468 () Int) -(declare-fun x_14 () Int) -(declare-fun x_832 () Int) -(declare-fun x_391 () Int) -(declare-fun x_517 () Int) -(declare-fun x_12 () Int) -(declare-fun x_244 () Int) -(declare-fun x_628 () Int) -(declare-fun x_334 () Int) -(declare-fun x_502 () Int) -(declare-fun x_883 () Int) -(declare-fun x_379 () Int) -(declare-fun x_307 () Int) -(declare-fun x_182 () Int) -(declare-fun x_293 () Int) -(declare-fun x_288 () Int) -(declare-fun x_633 () Int) -(declare-fun x_866 () Int) -(declare-fun x_571 () Int) -(declare-fun x_842 () Int) -(declare-fun x_921 () Int) -(declare-fun x_797 () Int) -(declare-fun x_153 () Int) -(declare-fun x_398 () Int) -(declare-fun x_583 () Int) -(declare-fun x_683 () Int) -(declare-fun x_189 () Int) -(declare-fun x_964 () Int) -(declare-fun x_164 () Int) -(declare-fun x_474 () Int) -(declare-fun x_521 () Int) -(declare-fun x_21 () Int) -(declare-fun x_518 () Int) -(declare-fun x_473 () Int) -(declare-fun x_896 () Int) -(declare-fun x_796 () Int) -(declare-fun x_477 () Int) -(declare-fun x_74 () Int) -(declare-fun x_116 () Int) -(declare-fun x_837 () Int) -(declare-fun x_673 () Int) -(declare-fun x_309 () Int) -(declare-fun x_58 () Int) -(declare-fun x_428 () Int) -(declare-fun x_589 () Int) -(declare-fun x_747 () Int) -(declare-fun x_929 () Int) -(declare-fun x_529 () Int) -(declare-fun x_413 () Int) -(declare-fun x_847 () Int) -(declare-fun x_262 () Int) -(declare-fun x_801 () Int) -(declare-fun x_952 () Int) -(declare-fun x_632 () Int) -(declare-fun x_142 () Int) -(declare-fun x_491 () Int) -(declare-fun x_546 () Int) -(declare-fun x_839 () Int) -(declare-fun x_588 () Int) -(declare-fun x_393 () Int) -(declare-fun x_118 () Int) -(declare-fun x_901 () Int) -(declare-fun x_962 () Int) -(declare-fun x_968 () Int) -(declare-fun x_886 () Int) -(declare-fun x_774 () Int) -(declare-fun x_487 () Int) -(declare-fun x_127 () Int) -(declare-fun x_237 () Int) -(declare-fun x_723 () Int) -(declare-fun x_542 () Int) -(declare-fun x_753 () Int) -(declare-fun x_129 () Int) -(declare-fun x_864 () Int) -(declare-fun x_611 () Int) -(declare-fun x_416 () Int) -(declare-fun x_947 () Int) -(declare-fun x_1202 () Int) -(declare-fun x_563 () Int) -(declare-fun x_337 () Int) -(declare-fun x_544 () Int) -(declare-fun x_654 () Int) -(declare-fun x_756 () Int) -(declare-fun x_744 () Int) -(declare-fun x_891 () Int) -(declare-fun x_378 () Int) -(declare-fun x_134 () Int) -(declare-fun x_208 () Int) -(declare-fun x_758 () Int) -(declare-fun x_848 () Int) -(declare-fun x_927 () Int) -(declare-fun x_937 () Int) -(declare-fun x_602 () Int) -(declare-fun x_349 () Int) -(declare-fun x_96 () Int) -(declare-fun x_162 () Int) -(declare-fun x_37 () Int) -(declare-fun x_941 () Int) -(declare-fun x_906 () Int) -(declare-fun x_811 () Int) -(declare-fun x_138 () Int) -(declare-fun x_621 () Int) -(declare-fun x_492 () Int) -(declare-fun x_764 () Int) -(declare-fun x_452 () Int) -(declare-fun x_851 () Int) -(declare-fun x_98 () Int) -(declare-fun x_236 () Int) -(declare-fun x_453 () Int) -(declare-fun x_978 () Int) -(declare-fun x_499 () Int) -(declare-fun x_494 () Int) -(declare-fun x_316 () Int) -(declare-fun x_587 () Int) -(declare-fun x_103 () Int) -(declare-fun x_734 () Int) -(declare-fun x_923 () Int) -(declare-fun x_228 () Int) -(declare-fun x_504 () Int) -(declare-fun x_564 () Int) -(declare-fun x_592 () Int) -(declare-fun x_2 () Int) -(declare-fun x_539 () Int) -(declare-fun x_247 () Int) -(declare-fun x_931 () Int) -(declare-fun x_903 () Int) -(declare-fun x_64 () Int) -(declare-fun x_232 () Int) -(declare-fun x_298 () Int) -(declare-fun x_126 () Int) -(declare-fun x_787 () Int) -(declare-fun x_243 () Int) -(declare-fun x_356 () Int) -(declare-fun x_709 () Int) -(declare-fun x_823 () Int) -(declare-fun x_338 () Int) -(declare-fun x_201 () Int) -(declare-fun x_304 () Int) -(declare-fun x_101 () Int) -(declare-fun x_568 () Int) -(declare-fun x_573 () Int) -(declare-fun x_28 () Int) -(declare-fun x_516 () Int) -(declare-fun x_619 () Int) -(declare-fun x_102 () Int) -(declare-fun x_92 () Int) -(declare-fun x_604 () Int) -(declare-fun x_597 () Int) -(declare-fun x_663 () Int) -(declare-fun x_731 () Int) -(declare-fun x_328 () Int) -(declare-fun x_143 () Int) -(declare-fun x_849 () Int) -(declare-fun x_128 () Int) -(declare-fun x_266 () Int) -(declare-fun x_203 () Int) -(declare-fun x_661 () Int) -(declare-fun x_996 () Int) -(declare-fun x_462 () Int) -(declare-fun x_977 () Int) -(declare-fun x_458 () Int) -(declare-fun x_933 () Int) -(declare-fun x_94 () Int) -(declare-fun x_332 () Int) -(declare-fun x_514 () Int) -(declare-fun x_969 () Int) -(declare-fun x_987 () Int) -(declare-fun x_497 () Int) -(declare-fun x_666 () Int) -(declare-fun x_858 () Int) -(declare-fun x_643 () Int) -(declare-fun x_523 () Int) -(declare-fun x_609 () Int) -(declare-fun x_263 () Int) -(declare-fun x_878 () Int) -(declare-fun x_981 () Int) -(declare-fun x_863 () Int) -(declare-fun x_324 () Int) -(declare-fun x_783 () Int) -(declare-fun x_241 () Int) -(declare-fun x_407 () Int) -(declare-fun x_708 () Int) -(declare-fun x_862 () Int) -(declare-fun x_757 () Int) -(declare-fun x_251 () Int) -(declare-fun x_771 () Int) -(declare-fun x_478 () Int) -(declare-fun x_437 () Int) -(declare-fun x_267 () Int) -(declare-fun x_599 () Int) -(declare-fun x_234 () Int) -(declare-fun x_177 () Int) -(declare-fun x_726 () Int) -(declare-fun x_261 () Int) -(declare-fun x_353 () Int) -(declare-fun x_732 () Int) -(declare-fun x_908 () Int) -(declare-fun x_361 () Int) -(declare-fun x_887 () Int) -(declare-fun x_488 () Int) -(declare-fun x_917 () Int) -(declare-fun x_716 () Int) -(declare-fun x_166 () Int) -(declare-fun x_112 () Int) -(declare-fun x_629 () Int) -(declare-fun x_52 () Int) -(declare-fun x_34 () Int) -(declare-fun x_183 () Int) -(declare-fun x_999 () Int) -(declare-fun x_99 () Int) -(declare-fun x_444 () Int) -(declare-fun x_424 () Int) -(declare-fun x_317 () Int) -(declare-fun x_784 () Int) -(declare-fun x_584 () Int) -(declare-fun x_282 () Int) -(declare-fun x_743 () Int) -(declare-fun x_56 () Int) -(declare-fun x_749 () Int) -(declare-fun x_411 () Int) -(declare-fun x_647 () Int) -(declare-fun x_219 () Int) -(declare-fun x_946 () Int) -(declare-fun x_433 () Int) -(declare-fun x_106 () Int) -(declare-fun x_38 () Int) -(declare-fun x_314 () Int) -(declare-fun x_481 () Int) -(declare-fun x_768 () Int) -(declare-fun x_579 () Int) -(declare-fun x_114 () Int) -(declare-fun x_894 () Int) -(declare-fun x_146 () Int) -(declare-fun x_577 () Int) -(declare-fun x_394 () Int) -(declare-fun x_566 () Int) -(declare-fun x_738 () Int) -(declare-fun x_506 () Int) -(declare-fun x_351 () Int) -(declare-fun x_493 () Int) -(declare-fun x_624 () Int) -(declare-fun x_653 () Int) -(declare-fun x_386 () Int) -(declare-fun x_526 () Int) -(declare-fun x_148 () Int) -(declare-fun x_131 () Int) -(declare-fun x_669 () Int) -(declare-fun x_982 () Int) -(declare-fun x_664 () Int) -(declare-fun x_501 () Int) -(declare-fun x_856 () Int) -(declare-fun x_828 () Int) -(declare-fun x_161 () Int) -(declare-fun x_772 () Int) -(declare-fun x_147 () Int) -(declare-fun x_967 () Int) -(declare-fun x_313 () Int) -(declare-fun x_681 () Int) -(declare-fun x_724 () Int) -(declare-fun x_636 () Int) -(declare-fun x_83 () Int) -(declare-fun x_754 () Int) -(declare-fun x_484 () Int) -(declare-fun x_49 () Int) -(declare-fun x_703 () Int) -(declare-fun x_36 () Int) -(declare-fun x_152 () Int) -(declare-fun x_187 () Int) -(declare-fun x_752 () Int) -(declare-fun x_191 () Int) -(declare-fun x_634 () Int) -(declare-fun x_788 () Int) -(declare-fun x_259 () Int) -(declare-fun x_431 () Int) -(declare-fun x_509 () Int) -(declare-fun x_93 () Int) -(declare-fun x_9 () Int) -(declare-fun x_513 () Int) -(declare-fun x_248 () Int) -(declare-fun x_272 () Int) -(declare-fun x_751 () Int) -(declare-fun x_686 () Int) -(declare-fun x_714 () Int) -(declare-fun x_807 () Int) -(declare-fun x_922 () Int) -(declare-fun x_81 () Int) -(declare-fun x_613 () Int) -(declare-fun x_928 () Int) -(declare-fun x_1604 () Int) -(declare-fun x_78 () Int) -(declare-fun x_249 () Int) -(declare-fun x_79 () Int) -(declare-fun x_649 () Int) -(declare-fun x_781 () Int) -(declare-fun x_687 () Int) -(declare-fun x_82 () Int) -(declare-fun x_804 () Int) -(declare-fun x_441 () Int) -(declare-fun x_651 () Int) -(declare-fun x_936 () Int) -(declare-fun x_1 () Int) -(declare-fun x_179 () Int) -(declare-fun x_199 () Int) -(declare-fun x_623 () Int) -(declare-fun x_794 () Int) -(declare-fun x_777 () Int) -(declare-fun x_214 () Int) -(declare-fun x_296 () Int) -(declare-fun x_949 () Int) -(declare-fun x_133 () Int) -(declare-fun x_829 () Int) -(declare-fun x_556 () Int) -(declare-fun x_617 () Int) -(declare-fun x_18 () Int) -(declare-fun x_728 () Int) -(declare-fun x_426 () Int) -(declare-fun x_898 () Int) -(declare-fun x_23 () Int) -(declare-fun x_843 () Int) -(declare-fun x_827 () Int) -(declare-fun x_831 () Int) -(declare-fun x_954 () Int) -(declare-fun x_341 () Int) -(declare-fun x_956 () Int) -(declare-fun x_983 () Int) -(declare-fun x_606 () Int) -(declare-fun x_874 () Int) -(declare-fun x_698 () Int) -(declare-fun x_782 () Int) -(declare-fun x_48 () Int) -(declare-fun x_172 () Int) -(declare-fun x_342 () Int) -(declare-fun x_238 () Int) -(declare-fun x_323 () Int) -(declare-fun x_608 () Int) -(declare-fun x_471 () Int) -(declare-fun x_216 () Int) -(declare-fun x_69 () Int) -(declare-fun x_438 () Int) -(declare-fun x_534 () Int) -(declare-fun x_368 () Int) -(declare-fun x_193 () Int) -(declare-fun x_532 () Int) -(declare-fun x_951 () Int) -(declare-fun x_258 () Int) -(declare-fun x_853 () Int) -(declare-fun x_132 () Int) -(declare-fun x_159 () Int) -(declare-fun x_217 () Int) -(declare-fun x_742 () Int) -(declare-fun x_311 () Int) -(declare-fun x_1403 () Int) -(declare-fun x_176 () Int) -(declare-fun x_254 () Int) -(declare-fun x_66 () Int) -(declare-fun x_144 () Int) -(declare-fun x_998 () Int) -(assert (<= 0 x_1)) -(assert (>= 1 x_1)) -(assert (<= 0 x_2)) -(assert (>= 1 x_2)) -(assert (<= 0 x_3)) -(assert (>= 1 x_3)) -(assert (<= 0 x_4)) -(assert (>= 1 x_4)) -(assert (<= 0 x_6)) -(assert (>= 1 x_6)) -(assert (<= 0 x_7)) -(assert (>= 1 x_7)) -(assert (<= 0 x_8)) -(assert (>= 1 x_8)) -(assert (<= 0 x_9)) -(assert (>= 1 x_9)) -(assert (<= 0 x_11)) -(assert (>= 1 x_11)) -(assert (<= 0 x_12)) -(assert (>= 1 x_12)) -(assert (<= 0 x_13)) -(assert (>= 1 x_13)) -(assert (<= 0 x_14)) -(assert (>= 1 x_14)) -(assert (<= 0 x_16)) -(assert (>= 1 x_16)) -(assert (<= 0 x_17)) -(assert (>= 1 x_17)) -(assert (<= 0 x_18)) -(assert (>= 1 x_18)) -(assert (<= 0 x_19)) -(assert (>= 1 x_19)) -(assert (<= 0 x_21)) -(assert (>= 1 x_21)) -(assert (<= 0 x_22)) -(assert (>= 1 x_22)) -(assert (<= 0 x_23)) -(assert (>= 1 x_23)) -(assert (<= 0 x_24)) -(assert (>= 1 x_24)) -(assert (<= 0 x_26)) -(assert (>= 1 x_26)) -(assert (<= 0 x_27)) -(assert (>= 1 x_27)) -(assert (<= 0 x_28)) -(assert (>= 1 x_28)) -(assert (<= 0 x_29)) -(assert (>= 1 x_29)) -(assert (<= 0 x_31)) -(assert (>= 1 x_31)) -(assert (<= 0 x_32)) -(assert (>= 1 x_32)) -(assert (<= 0 x_33)) -(assert (>= 1 x_33)) -(assert (<= 0 x_34)) -(assert (>= 1 x_34)) -(assert (<= 0 x_36)) -(assert (>= 1 x_36)) -(assert (<= 0 x_37)) -(assert (>= 1 x_37)) -(assert (<= 0 x_38)) -(assert (>= 1 x_38)) -(assert (<= 0 x_39)) -(assert (>= 1 x_39)) -(assert (<= 0 x_41)) -(assert (>= 1 x_41)) -(assert (<= 0 x_42)) -(assert (>= 1 x_42)) -(assert (<= 0 x_43)) -(assert (>= 1 x_43)) -(assert (<= 0 x_44)) -(assert (>= 1 x_44)) -(assert (<= 0 x_46)) -(assert (>= 1 x_46)) -(assert (<= 0 x_47)) -(assert (>= 1 x_47)) -(assert (<= 0 x_48)) -(assert (>= 1 x_48)) -(assert (<= 0 x_49)) -(assert (>= 1 x_49)) -(assert (<= 0 x_51)) -(assert (>= 1 x_51)) -(assert (<= 0 x_52)) -(assert (>= 1 x_52)) -(assert (<= 0 x_53)) -(assert (>= 1 x_53)) -(assert (<= 0 x_54)) -(assert (>= 1 x_54)) -(assert (<= 0 x_56)) -(assert (>= 1 x_56)) -(assert (<= 0 x_57)) -(assert (>= 1 x_57)) -(assert (<= 0 x_58)) -(assert (>= 1 x_58)) -(assert (<= 0 x_59)) -(assert (>= 1 x_59)) -(assert (<= 0 x_61)) -(assert (>= 1 x_61)) -(assert (<= 0 x_62)) -(assert (>= 1 x_62)) -(assert (<= 0 x_63)) -(assert (>= 1 x_63)) -(assert (<= 0 x_64)) -(assert (>= 1 x_64)) -(assert (<= 0 x_66)) -(assert (>= 1 x_66)) -(assert (<= 0 x_67)) -(assert (>= 1 x_67)) -(assert (<= 0 x_68)) -(assert (>= 1 x_68)) -(assert (<= 0 x_69)) -(assert (>= 1 x_69)) -(assert (<= 0 x_71)) -(assert (>= 1 x_71)) -(assert (<= 0 x_72)) -(assert (>= 1 x_72)) -(assert (<= 0 x_73)) -(assert (>= 1 x_73)) -(assert (<= 0 x_74)) -(assert (>= 1 x_74)) -(assert (<= 0 x_76)) -(assert (>= 1 x_76)) -(assert (<= 0 x_77)) -(assert (>= 1 x_77)) -(assert (<= 0 x_78)) -(assert (>= 1 x_78)) -(assert (<= 0 x_79)) -(assert (>= 1 x_79)) -(assert (<= 0 x_81)) -(assert (>= 1 x_81)) -(assert (<= 0 x_82)) -(assert (>= 1 x_82)) -(assert (<= 0 x_83)) -(assert (>= 1 x_83)) -(assert (<= 0 x_84)) -(assert (>= 1 x_84)) -(assert (<= 0 x_86)) -(assert (>= 1 x_86)) -(assert (<= 0 x_87)) -(assert (>= 1 x_87)) -(assert (<= 0 x_88)) -(assert (>= 1 x_88)) -(assert (<= 0 x_89)) -(assert (>= 1 x_89)) -(assert (<= 0 x_91)) -(assert (>= 1 x_91)) -(assert (<= 0 x_92)) -(assert (>= 1 x_92)) -(assert (<= 0 x_93)) -(assert (>= 1 x_93)) -(assert (<= 0 x_94)) -(assert (>= 1 x_94)) -(assert (<= 0 x_96)) -(assert (>= 1 x_96)) -(assert (<= 0 x_97)) -(assert (>= 1 x_97)) -(assert (<= 0 x_98)) -(assert (>= 1 x_98)) -(assert (<= 0 x_99)) -(assert (>= 1 x_99)) -(assert (<= 0 x_101)) -(assert (>= 1 x_101)) -(assert (<= 0 x_102)) -(assert (>= 1 x_102)) -(assert (<= 0 x_103)) -(assert (>= 1 x_103)) -(assert (<= 0 x_104)) -(assert (>= 1 x_104)) -(assert (<= 0 x_106)) -(assert (>= 1 x_106)) -(assert (<= 0 x_107)) -(assert (>= 1 x_107)) -(assert (<= 0 x_108)) -(assert (>= 1 x_108)) -(assert (<= 0 x_109)) -(assert (>= 1 x_109)) -(assert (<= 0 x_111)) -(assert (>= 1 x_111)) -(assert (<= 0 x_112)) -(assert (>= 1 x_112)) -(assert (<= 0 x_113)) -(assert (>= 1 x_113)) -(assert (<= 0 x_114)) -(assert (>= 1 x_114)) -(assert (<= 0 x_116)) -(assert (>= 1 x_116)) -(assert (<= 0 x_117)) -(assert (>= 1 x_117)) -(assert (<= 0 x_118)) -(assert (>= 1 x_118)) -(assert (<= 0 x_119)) -(assert (>= 1 x_119)) -(assert (<= 0 x_121)) -(assert (>= 1 x_121)) -(assert (<= 0 x_122)) -(assert (>= 1 x_122)) -(assert (<= 0 x_123)) -(assert (>= 1 x_123)) -(assert (<= 0 x_124)) -(assert (>= 1 x_124)) -(assert (<= 0 x_126)) -(assert (>= 1 x_126)) -(assert (<= 0 x_127)) -(assert (>= 1 x_127)) -(assert (<= 0 x_128)) -(assert (>= 1 x_128)) -(assert (<= 0 x_129)) -(assert (>= 1 x_129)) -(assert (<= 0 x_131)) -(assert (>= 1 x_131)) -(assert (<= 0 x_132)) -(assert (>= 1 x_132)) -(assert (<= 0 x_133)) -(assert (>= 1 x_133)) -(assert (<= 0 x_134)) -(assert (>= 1 x_134)) -(assert (<= 0 x_136)) -(assert (>= 1 x_136)) -(assert (<= 0 x_137)) -(assert (>= 1 x_137)) -(assert (<= 0 x_138)) -(assert (>= 1 x_138)) -(assert (<= 0 x_139)) -(assert (>= 1 x_139)) -(assert (<= 0 x_141)) -(assert (>= 1 x_141)) -(assert (<= 0 x_142)) -(assert (>= 1 x_142)) -(assert (<= 0 x_143)) -(assert (>= 1 x_143)) -(assert (<= 0 x_144)) -(assert (>= 1 x_144)) -(assert (<= 0 x_146)) -(assert (>= 1 x_146)) -(assert (<= 0 x_147)) -(assert (>= 1 x_147)) -(assert (<= 0 x_148)) -(assert (>= 1 x_148)) -(assert (<= 0 x_149)) -(assert (>= 1 x_149)) -(assert (<= 0 x_151)) -(assert (>= 1 x_151)) -(assert (<= 0 x_152)) -(assert (>= 1 x_152)) -(assert (<= 0 x_153)) -(assert (>= 1 x_153)) -(assert (<= 0 x_154)) -(assert (>= 1 x_154)) -(assert (<= 0 x_156)) -(assert (>= 1 x_156)) -(assert (<= 0 x_157)) -(assert (>= 1 x_157)) -(assert (<= 0 x_158)) -(assert (>= 1 x_158)) -(assert (<= 0 x_159)) -(assert (>= 1 x_159)) -(assert (<= 0 x_161)) -(assert (>= 1 x_161)) -(assert (<= 0 x_162)) -(assert (>= 1 x_162)) -(assert (<= 0 x_163)) -(assert (>= 1 x_163)) -(assert (<= 0 x_164)) -(assert (>= 1 x_164)) -(assert (<= 0 x_166)) -(assert (>= 1 x_166)) -(assert (<= 0 x_167)) -(assert (>= 1 x_167)) -(assert (<= 0 x_168)) -(assert (>= 1 x_168)) -(assert (<= 0 x_169)) -(assert (>= 1 x_169)) -(assert (<= 0 x_171)) -(assert (>= 1 x_171)) -(assert (<= 0 x_172)) -(assert (>= 1 x_172)) -(assert (<= 0 x_173)) -(assert (>= 1 x_173)) -(assert (<= 0 x_174)) -(assert (>= 1 x_174)) -(assert (<= 0 x_176)) -(assert (>= 1 x_176)) -(assert (<= 0 x_177)) -(assert (>= 1 x_177)) -(assert (<= 0 x_178)) -(assert (>= 1 x_178)) -(assert (<= 0 x_179)) -(assert (>= 1 x_179)) -(assert (<= 0 x_181)) -(assert (>= 1 x_181)) -(assert (<= 0 x_182)) -(assert (>= 1 x_182)) -(assert (<= 0 x_183)) -(assert (>= 1 x_183)) -(assert (<= 0 x_184)) -(assert (>= 1 x_184)) -(assert (<= 0 x_186)) -(assert (>= 1 x_186)) -(assert (<= 0 x_187)) -(assert (>= 1 x_187)) -(assert (<= 0 x_188)) -(assert (>= 1 x_188)) -(assert (<= 0 x_189)) -(assert (>= 1 x_189)) -(assert (<= 0 x_191)) -(assert (>= 1 x_191)) -(assert (<= 0 x_192)) -(assert (>= 1 x_192)) -(assert (<= 0 x_193)) -(assert (>= 1 x_193)) -(assert (<= 0 x_194)) -(assert (>= 1 x_194)) -(assert (<= 0 x_196)) -(assert (>= 1 x_196)) -(assert (<= 0 x_197)) -(assert (>= 1 x_197)) -(assert (<= 0 x_198)) -(assert (>= 1 x_198)) -(assert (<= 0 x_199)) -(assert (>= 1 x_199)) -(assert (<= 0 x_201)) -(assert (>= 1 x_201)) -(assert (<= 0 x_202)) -(assert (>= 1 x_202)) -(assert (<= 0 x_203)) -(assert (>= 1 x_203)) -(assert (<= 0 x_204)) -(assert (>= 1 x_204)) -(assert (<= 0 x_206)) -(assert (>= 1 x_206)) -(assert (<= 0 x_207)) -(assert (>= 1 x_207)) -(assert (<= 0 x_208)) -(assert (>= 1 x_208)) -(assert (<= 0 x_209)) -(assert (>= 1 x_209)) -(assert (<= 0 x_211)) -(assert (>= 1 x_211)) -(assert (<= 0 x_212)) -(assert (>= 1 x_212)) -(assert (<= 0 x_213)) -(assert (>= 1 x_213)) -(assert (<= 0 x_214)) -(assert (>= 1 x_214)) -(assert (<= 0 x_216)) -(assert (>= 1 x_216)) -(assert (<= 0 x_217)) -(assert (>= 1 x_217)) -(assert (<= 0 x_218)) -(assert (>= 1 x_218)) -(assert (<= 0 x_219)) -(assert (>= 1 x_219)) -(assert (<= 0 x_221)) -(assert (>= 1 x_221)) -(assert (<= 0 x_222)) -(assert (>= 1 x_222)) -(assert (<= 0 x_223)) -(assert (>= 1 x_223)) -(assert (<= 0 x_224)) -(assert (>= 1 x_224)) -(assert (<= 0 x_226)) -(assert (>= 1 x_226)) -(assert (<= 0 x_227)) -(assert (>= 1 x_227)) -(assert (<= 0 x_228)) -(assert (>= 1 x_228)) -(assert (<= 0 x_229)) -(assert (>= 1 x_229)) -(assert (<= 0 x_231)) -(assert (>= 1 x_231)) -(assert (<= 0 x_232)) -(assert (>= 1 x_232)) -(assert (<= 0 x_233)) -(assert (>= 1 x_233)) -(assert (<= 0 x_234)) -(assert (>= 1 x_234)) -(assert (<= 0 x_236)) -(assert (>= 1 x_236)) -(assert (<= 0 x_237)) -(assert (>= 1 x_237)) -(assert (<= 0 x_238)) -(assert (>= 1 x_238)) -(assert (<= 0 x_239)) -(assert (>= 1 x_239)) -(assert (<= 0 x_241)) -(assert (>= 1 x_241)) -(assert (<= 0 x_242)) -(assert (>= 1 x_242)) -(assert (<= 0 x_243)) -(assert (>= 1 x_243)) -(assert (<= 0 x_244)) -(assert (>= 1 x_244)) -(assert (<= 0 x_246)) -(assert (>= 1 x_246)) -(assert (<= 0 x_247)) -(assert (>= 1 x_247)) -(assert (<= 0 x_248)) -(assert (>= 1 x_248)) -(assert (<= 0 x_249)) -(assert (>= 1 x_249)) -(assert (<= 0 x_251)) -(assert (>= 1 x_251)) -(assert (<= 0 x_252)) -(assert (>= 1 x_252)) -(assert (<= 0 x_253)) -(assert (>= 1 x_253)) -(assert (<= 0 x_254)) -(assert (>= 1 x_254)) -(assert (<= 0 x_256)) -(assert (>= 1 x_256)) -(assert (<= 0 x_257)) -(assert (>= 1 x_257)) -(assert (<= 0 x_258)) -(assert (>= 1 x_258)) -(assert (<= 0 x_259)) -(assert (>= 1 x_259)) -(assert (<= 0 x_261)) -(assert (>= 1 x_261)) -(assert (<= 0 x_262)) -(assert (>= 1 x_262)) -(assert (<= 0 x_263)) -(assert (>= 1 x_263)) -(assert (<= 0 x_264)) -(assert (>= 1 x_264)) -(assert (<= 0 x_266)) -(assert (>= 1 x_266)) -(assert (<= 0 x_267)) -(assert (>= 1 x_267)) -(assert (<= 0 x_268)) -(assert (>= 1 x_268)) -(assert (<= 0 x_269)) -(assert (>= 1 x_269)) -(assert (<= 0 x_271)) -(assert (>= 1 x_271)) -(assert (<= 0 x_272)) -(assert (>= 1 x_272)) -(assert (<= 0 x_273)) -(assert (>= 1 x_273)) -(assert (<= 0 x_274)) -(assert (>= 1 x_274)) -(assert (<= 0 x_276)) -(assert (>= 1 x_276)) -(assert (<= 0 x_277)) -(assert (>= 1 x_277)) -(assert (<= 0 x_278)) -(assert (>= 1 x_278)) -(assert (<= 0 x_279)) -(assert (>= 1 x_279)) -(assert (<= 0 x_281)) -(assert (>= 1 x_281)) -(assert (<= 0 x_282)) -(assert (>= 1 x_282)) -(assert (<= 0 x_283)) -(assert (>= 1 x_283)) -(assert (<= 0 x_284)) -(assert (>= 1 x_284)) -(assert (<= 0 x_286)) -(assert (>= 1 x_286)) -(assert (<= 0 x_287)) -(assert (>= 1 x_287)) -(assert (<= 0 x_288)) -(assert (>= 1 x_288)) -(assert (<= 0 x_289)) -(assert (>= 1 x_289)) -(assert (<= 0 x_291)) -(assert (>= 1 x_291)) -(assert (<= 0 x_292)) -(assert (>= 1 x_292)) -(assert (<= 0 x_293)) -(assert (>= 1 x_293)) -(assert (<= 0 x_294)) -(assert (>= 1 x_294)) -(assert (<= 0 x_296)) -(assert (>= 1 x_296)) -(assert (<= 0 x_297)) -(assert (>= 1 x_297)) -(assert (<= 0 x_298)) -(assert (>= 1 x_298)) -(assert (<= 0 x_299)) -(assert (>= 1 x_299)) -(assert (<= 0 x_301)) -(assert (>= 1 x_301)) -(assert (<= 0 x_302)) -(assert (>= 1 x_302)) -(assert (<= 0 x_303)) -(assert (>= 1 x_303)) -(assert (<= 0 x_304)) -(assert (>= 1 x_304)) -(assert (<= 0 x_306)) -(assert (>= 1 x_306)) -(assert (<= 0 x_307)) -(assert (>= 1 x_307)) -(assert (<= 0 x_308)) -(assert (>= 1 x_308)) -(assert (<= 0 x_309)) -(assert (>= 1 x_309)) -(assert (<= 0 x_311)) -(assert (>= 1 x_311)) -(assert (<= 0 x_312)) -(assert (>= 1 x_312)) -(assert (<= 0 x_313)) -(assert (>= 1 x_313)) -(assert (<= 0 x_314)) -(assert (>= 1 x_314)) -(assert (<= 0 x_316)) -(assert (>= 1 x_316)) -(assert (<= 0 x_317)) -(assert (>= 1 x_317)) -(assert (<= 0 x_318)) -(assert (>= 1 x_318)) -(assert (<= 0 x_319)) -(assert (>= 1 x_319)) -(assert (<= 0 x_321)) -(assert (>= 1 x_321)) -(assert (<= 0 x_322)) -(assert (>= 1 x_322)) -(assert (<= 0 x_323)) -(assert (>= 1 x_323)) -(assert (<= 0 x_324)) -(assert (>= 1 x_324)) -(assert (<= 0 x_326)) -(assert (>= 1 x_326)) -(assert (<= 0 x_327)) -(assert (>= 1 x_327)) -(assert (<= 0 x_328)) -(assert (>= 1 x_328)) -(assert (<= 0 x_329)) -(assert (>= 1 x_329)) -(assert (<= 0 x_331)) -(assert (>= 1 x_331)) -(assert (<= 0 x_332)) -(assert (>= 1 x_332)) -(assert (<= 0 x_333)) -(assert (>= 1 x_333)) -(assert (<= 0 x_334)) -(assert (>= 1 x_334)) -(assert (<= 0 x_336)) -(assert (>= 1 x_336)) -(assert (<= 0 x_337)) -(assert (>= 1 x_337)) -(assert (<= 0 x_338)) -(assert (>= 1 x_338)) -(assert (<= 0 x_339)) -(assert (>= 1 x_339)) -(assert (<= 0 x_341)) -(assert (>= 1 x_341)) -(assert (<= 0 x_342)) -(assert (>= 1 x_342)) -(assert (<= 0 x_343)) -(assert (>= 1 x_343)) -(assert (<= 0 x_344)) -(assert (>= 1 x_344)) -(assert (<= 0 x_346)) -(assert (>= 1 x_346)) -(assert (<= 0 x_347)) -(assert (>= 1 x_347)) -(assert (<= 0 x_348)) -(assert (>= 1 x_348)) -(assert (<= 0 x_349)) -(assert (>= 1 x_349)) -(assert (<= 0 x_351)) -(assert (>= 1 x_351)) -(assert (<= 0 x_352)) -(assert (>= 1 x_352)) -(assert (<= 0 x_353)) -(assert (>= 1 x_353)) -(assert (<= 0 x_354)) -(assert (>= 1 x_354)) -(assert (<= 0 x_356)) -(assert (>= 1 x_356)) -(assert (<= 0 x_357)) -(assert (>= 1 x_357)) -(assert (<= 0 x_358)) -(assert (>= 1 x_358)) -(assert (<= 0 x_359)) -(assert (>= 1 x_359)) -(assert (<= 0 x_361)) -(assert (>= 1 x_361)) -(assert (<= 0 x_362)) -(assert (>= 1 x_362)) -(assert (<= 0 x_363)) -(assert (>= 1 x_363)) -(assert (<= 0 x_364)) -(assert (>= 1 x_364)) -(assert (<= 0 x_366)) -(assert (>= 1 x_366)) -(assert (<= 0 x_367)) -(assert (>= 1 x_367)) -(assert (<= 0 x_368)) -(assert (>= 1 x_368)) -(assert (<= 0 x_369)) -(assert (>= 1 x_369)) -(assert (<= 0 x_371)) -(assert (>= 1 x_371)) -(assert (<= 0 x_372)) -(assert (>= 1 x_372)) -(assert (<= 0 x_373)) -(assert (>= 1 x_373)) -(assert (<= 0 x_374)) -(assert (>= 1 x_374)) -(assert (<= 0 x_376)) -(assert (>= 1 x_376)) -(assert (<= 0 x_377)) -(assert (>= 1 x_377)) -(assert (<= 0 x_378)) -(assert (>= 1 x_378)) -(assert (<= 0 x_379)) -(assert (>= 1 x_379)) -(assert (<= 0 x_381)) -(assert (>= 1 x_381)) -(assert (<= 0 x_382)) -(assert (>= 1 x_382)) -(assert (<= 0 x_383)) -(assert (>= 1 x_383)) -(assert (<= 0 x_384)) -(assert (>= 1 x_384)) -(assert (<= 0 x_386)) -(assert (>= 1 x_386)) -(assert (<= 0 x_387)) -(assert (>= 1 x_387)) -(assert (<= 0 x_388)) -(assert (>= 1 x_388)) -(assert (<= 0 x_389)) -(assert (>= 1 x_389)) -(assert (<= 0 x_391)) -(assert (>= 1 x_391)) -(assert (<= 0 x_392)) -(assert (>= 1 x_392)) -(assert (<= 0 x_393)) -(assert (>= 1 x_393)) -(assert (<= 0 x_394)) -(assert (>= 1 x_394)) -(assert (<= 0 x_396)) -(assert (>= 1 x_396)) -(assert (<= 0 x_397)) -(assert (>= 1 x_397)) -(assert (<= 0 x_398)) -(assert (>= 1 x_398)) -(assert (<= 0 x_399)) -(assert (>= 1 x_399)) -(assert (<= 0 x_401)) -(assert (>= 1 x_401)) -(assert (<= 0 x_402)) -(assert (>= 1 x_402)) -(assert (<= 0 x_403)) -(assert (>= 1 x_403)) -(assert (<= 0 x_404)) -(assert (>= 1 x_404)) -(assert (<= 0 x_406)) -(assert (>= 1 x_406)) -(assert (<= 0 x_407)) -(assert (>= 1 x_407)) -(assert (<= 0 x_408)) -(assert (>= 1 x_408)) -(assert (<= 0 x_409)) -(assert (>= 1 x_409)) -(assert (<= 0 x_411)) -(assert (>= 1 x_411)) -(assert (<= 0 x_412)) -(assert (>= 1 x_412)) -(assert (<= 0 x_413)) -(assert (>= 1 x_413)) -(assert (<= 0 x_414)) -(assert (>= 1 x_414)) -(assert (<= 0 x_416)) -(assert (>= 1 x_416)) -(assert (<= 0 x_417)) -(assert (>= 1 x_417)) -(assert (<= 0 x_418)) -(assert (>= 1 x_418)) -(assert (<= 0 x_419)) -(assert (>= 1 x_419)) -(assert (<= 0 x_421)) -(assert (>= 1 x_421)) -(assert (<= 0 x_422)) -(assert (>= 1 x_422)) -(assert (<= 0 x_423)) -(assert (>= 1 x_423)) -(assert (<= 0 x_424)) -(assert (>= 1 x_424)) -(assert (<= 0 x_426)) -(assert (>= 1 x_426)) -(assert (<= 0 x_427)) -(assert (>= 1 x_427)) -(assert (<= 0 x_428)) -(assert (>= 1 x_428)) -(assert (<= 0 x_429)) -(assert (>= 1 x_429)) -(assert (<= 0 x_431)) -(assert (>= 1 x_431)) -(assert (<= 0 x_432)) -(assert (>= 1 x_432)) -(assert (<= 0 x_433)) -(assert (>= 1 x_433)) -(assert (<= 0 x_434)) -(assert (>= 1 x_434)) -(assert (<= 0 x_436)) -(assert (>= 1 x_436)) -(assert (<= 0 x_437)) -(assert (>= 1 x_437)) -(assert (<= 0 x_438)) -(assert (>= 1 x_438)) -(assert (<= 0 x_439)) -(assert (>= 1 x_439)) -(assert (<= 0 x_441)) -(assert (>= 1 x_441)) -(assert (<= 0 x_442)) -(assert (>= 1 x_442)) -(assert (<= 0 x_443)) -(assert (>= 1 x_443)) -(assert (<= 0 x_444)) -(assert (>= 1 x_444)) -(assert (<= 0 x_446)) -(assert (>= 1 x_446)) -(assert (<= 0 x_447)) -(assert (>= 1 x_447)) -(assert (<= 0 x_448)) -(assert (>= 1 x_448)) -(assert (<= 0 x_449)) -(assert (>= 1 x_449)) -(assert (<= 0 x_451)) -(assert (>= 1 x_451)) -(assert (<= 0 x_452)) -(assert (>= 1 x_452)) -(assert (<= 0 x_453)) -(assert (>= 1 x_453)) -(assert (<= 0 x_454)) -(assert (>= 1 x_454)) -(assert (<= 0 x_456)) -(assert (>= 1 x_456)) -(assert (<= 0 x_457)) -(assert (>= 1 x_457)) -(assert (<= 0 x_458)) -(assert (>= 1 x_458)) -(assert (<= 0 x_459)) -(assert (>= 1 x_459)) -(assert (<= 0 x_461)) -(assert (>= 1 x_461)) -(assert (<= 0 x_462)) -(assert (>= 1 x_462)) -(assert (<= 0 x_463)) -(assert (>= 1 x_463)) -(assert (<= 0 x_464)) -(assert (>= 1 x_464)) -(assert (<= 0 x_466)) -(assert (>= 1 x_466)) -(assert (<= 0 x_467)) -(assert (>= 1 x_467)) -(assert (<= 0 x_468)) -(assert (>= 1 x_468)) -(assert (<= 0 x_469)) -(assert (>= 1 x_469)) -(assert (<= 0 x_471)) -(assert (>= 1 x_471)) -(assert (<= 0 x_472)) -(assert (>= 1 x_472)) -(assert (<= 0 x_473)) -(assert (>= 1 x_473)) -(assert (<= 0 x_474)) -(assert (>= 1 x_474)) -(assert (<= 0 x_476)) -(assert (>= 1 x_476)) -(assert (<= 0 x_477)) -(assert (>= 1 x_477)) -(assert (<= 0 x_478)) -(assert (>= 1 x_478)) -(assert (<= 0 x_479)) -(assert (>= 1 x_479)) -(assert (<= 0 x_481)) -(assert (>= 1 x_481)) -(assert (<= 0 x_482)) -(assert (>= 1 x_482)) -(assert (<= 0 x_483)) -(assert (>= 1 x_483)) -(assert (<= 0 x_484)) -(assert (>= 1 x_484)) -(assert (<= 0 x_486)) -(assert (>= 1 x_486)) -(assert (<= 0 x_487)) -(assert (>= 1 x_487)) -(assert (<= 0 x_488)) -(assert (>= 1 x_488)) -(assert (<= 0 x_489)) -(assert (>= 1 x_489)) -(assert (<= 0 x_491)) -(assert (>= 1 x_491)) -(assert (<= 0 x_492)) -(assert (>= 1 x_492)) -(assert (<= 0 x_493)) -(assert (>= 1 x_493)) -(assert (<= 0 x_494)) -(assert (>= 1 x_494)) -(assert (<= 0 x_496)) -(assert (>= 1 x_496)) -(assert (<= 0 x_497)) -(assert (>= 1 x_497)) -(assert (<= 0 x_498)) -(assert (>= 1 x_498)) -(assert (<= 0 x_499)) -(assert (>= 1 x_499)) -(assert (<= 0 x_501)) -(assert (>= 1 x_501)) -(assert (<= 0 x_502)) -(assert (>= 1 x_502)) -(assert (<= 0 x_503)) -(assert (>= 1 x_503)) -(assert (<= 0 x_504)) -(assert (>= 1 x_504)) -(assert (<= 0 x_506)) -(assert (>= 1 x_506)) -(assert (<= 0 x_507)) -(assert (>= 1 x_507)) -(assert (<= 0 x_508)) -(assert (>= 1 x_508)) -(assert (<= 0 x_509)) -(assert (>= 1 x_509)) -(assert (<= 0 x_511)) -(assert (>= 1 x_511)) -(assert (<= 0 x_512)) -(assert (>= 1 x_512)) -(assert (<= 0 x_513)) -(assert (>= 1 x_513)) -(assert (<= 0 x_514)) -(assert (>= 1 x_514)) -(assert (<= 0 x_516)) -(assert (>= 1 x_516)) -(assert (<= 0 x_517)) -(assert (>= 1 x_517)) -(assert (<= 0 x_518)) -(assert (>= 1 x_518)) -(assert (<= 0 x_519)) -(assert (>= 1 x_519)) -(assert (<= 0 x_521)) -(assert (>= 1 x_521)) -(assert (<= 0 x_522)) -(assert (>= 1 x_522)) -(assert (<= 0 x_523)) -(assert (>= 1 x_523)) -(assert (<= 0 x_524)) -(assert (>= 1 x_524)) -(assert (<= 0 x_526)) -(assert (>= 1 x_526)) -(assert (<= 0 x_527)) -(assert (>= 1 x_527)) -(assert (<= 0 x_528)) -(assert (>= 1 x_528)) -(assert (<= 0 x_529)) -(assert (>= 1 x_529)) -(assert (<= 0 x_531)) -(assert (>= 1 x_531)) -(assert (<= 0 x_532)) -(assert (>= 1 x_532)) -(assert (<= 0 x_533)) -(assert (>= 1 x_533)) -(assert (<= 0 x_534)) -(assert (>= 1 x_534)) -(assert (<= 0 x_536)) -(assert (>= 1 x_536)) -(assert (<= 0 x_537)) -(assert (>= 1 x_537)) -(assert (<= 0 x_538)) -(assert (>= 1 x_538)) -(assert (<= 0 x_539)) -(assert (>= 1 x_539)) -(assert (<= 0 x_541)) -(assert (>= 1 x_541)) -(assert (<= 0 x_542)) -(assert (>= 1 x_542)) -(assert (<= 0 x_543)) -(assert (>= 1 x_543)) -(assert (<= 0 x_544)) -(assert (>= 1 x_544)) -(assert (<= 0 x_546)) -(assert (>= 1 x_546)) -(assert (<= 0 x_547)) -(assert (>= 1 x_547)) -(assert (<= 0 x_548)) -(assert (>= 1 x_548)) -(assert (<= 0 x_549)) -(assert (>= 1 x_549)) -(assert (<= 0 x_551)) -(assert (>= 1 x_551)) -(assert (<= 0 x_552)) -(assert (>= 1 x_552)) -(assert (<= 0 x_553)) -(assert (>= 1 x_553)) -(assert (<= 0 x_554)) -(assert (>= 1 x_554)) -(assert (<= 0 x_556)) -(assert (>= 1 x_556)) -(assert (<= 0 x_557)) -(assert (>= 1 x_557)) -(assert (<= 0 x_558)) -(assert (>= 1 x_558)) -(assert (<= 0 x_559)) -(assert (>= 1 x_559)) -(assert (<= 0 x_561)) -(assert (>= 1 x_561)) -(assert (<= 0 x_562)) -(assert (>= 1 x_562)) -(assert (<= 0 x_563)) -(assert (>= 1 x_563)) -(assert (<= 0 x_564)) -(assert (>= 1 x_564)) -(assert (<= 0 x_566)) -(assert (>= 1 x_566)) -(assert (<= 0 x_567)) -(assert (>= 1 x_567)) -(assert (<= 0 x_568)) -(assert (>= 1 x_568)) -(assert (<= 0 x_569)) -(assert (>= 1 x_569)) -(assert (<= 0 x_571)) -(assert (>= 1 x_571)) -(assert (<= 0 x_572)) -(assert (>= 1 x_572)) -(assert (<= 0 x_573)) -(assert (>= 1 x_573)) -(assert (<= 0 x_574)) -(assert (>= 1 x_574)) -(assert (<= 0 x_576)) -(assert (>= 1 x_576)) -(assert (<= 0 x_577)) -(assert (>= 1 x_577)) -(assert (<= 0 x_578)) -(assert (>= 1 x_578)) -(assert (<= 0 x_579)) -(assert (>= 1 x_579)) -(assert (<= 0 x_581)) -(assert (>= 1 x_581)) -(assert (<= 0 x_582)) -(assert (>= 1 x_582)) -(assert (<= 0 x_583)) -(assert (>= 1 x_583)) -(assert (<= 0 x_584)) -(assert (>= 1 x_584)) -(assert (<= 0 x_586)) -(assert (>= 1 x_586)) -(assert (<= 0 x_587)) -(assert (>= 1 x_587)) -(assert (<= 0 x_588)) -(assert (>= 1 x_588)) -(assert (<= 0 x_589)) -(assert (>= 1 x_589)) -(assert (<= 0 x_591)) -(assert (>= 1 x_591)) -(assert (<= 0 x_592)) -(assert (>= 1 x_592)) -(assert (<= 0 x_593)) -(assert (>= 1 x_593)) -(assert (<= 0 x_594)) -(assert (>= 1 x_594)) -(assert (<= 0 x_596)) -(assert (>= 1 x_596)) -(assert (<= 0 x_597)) -(assert (>= 1 x_597)) -(assert (<= 0 x_598)) -(assert (>= 1 x_598)) -(assert (<= 0 x_599)) -(assert (>= 1 x_599)) -(assert (<= 0 x_601)) -(assert (>= 1 x_601)) -(assert (<= 0 x_602)) -(assert (>= 1 x_602)) -(assert (<= 0 x_603)) -(assert (>= 1 x_603)) -(assert (<= 0 x_604)) -(assert (>= 1 x_604)) -(assert (<= 0 x_606)) -(assert (>= 1 x_606)) -(assert (<= 0 x_607)) -(assert (>= 1 x_607)) -(assert (<= 0 x_608)) -(assert (>= 1 x_608)) -(assert (<= 0 x_609)) -(assert (>= 1 x_609)) -(assert (<= 0 x_611)) -(assert (>= 1 x_611)) -(assert (<= 0 x_612)) -(assert (>= 1 x_612)) -(assert (<= 0 x_613)) -(assert (>= 1 x_613)) -(assert (<= 0 x_614)) -(assert (>= 1 x_614)) -(assert (<= 0 x_616)) -(assert (>= 1 x_616)) -(assert (<= 0 x_617)) -(assert (>= 1 x_617)) -(assert (<= 0 x_618)) -(assert (>= 1 x_618)) -(assert (<= 0 x_619)) -(assert (>= 1 x_619)) -(assert (<= 0 x_621)) -(assert (>= 1 x_621)) -(assert (<= 0 x_622)) -(assert (>= 1 x_622)) -(assert (<= 0 x_623)) -(assert (>= 1 x_623)) -(assert (<= 0 x_624)) -(assert (>= 1 x_624)) -(assert (<= 0 x_626)) -(assert (>= 1 x_626)) -(assert (<= 0 x_627)) -(assert (>= 1 x_627)) -(assert (<= 0 x_628)) -(assert (>= 1 x_628)) -(assert (<= 0 x_629)) -(assert (>= 1 x_629)) -(assert (<= 0 x_631)) -(assert (>= 1 x_631)) -(assert (<= 0 x_632)) -(assert (>= 1 x_632)) -(assert (<= 0 x_633)) -(assert (>= 1 x_633)) -(assert (<= 0 x_634)) -(assert (>= 1 x_634)) -(assert (<= 0 x_636)) -(assert (>= 1 x_636)) -(assert (<= 0 x_637)) -(assert (>= 1 x_637)) -(assert (<= 0 x_638)) -(assert (>= 1 x_638)) -(assert (<= 0 x_639)) -(assert (>= 1 x_639)) -(assert (<= 0 x_641)) -(assert (>= 1 x_641)) -(assert (<= 0 x_642)) -(assert (>= 1 x_642)) -(assert (<= 0 x_643)) -(assert (>= 1 x_643)) -(assert (<= 0 x_644)) -(assert (>= 1 x_644)) -(assert (<= 0 x_646)) -(assert (>= 1 x_646)) -(assert (<= 0 x_647)) -(assert (>= 1 x_647)) -(assert (<= 0 x_648)) -(assert (>= 1 x_648)) -(assert (<= 0 x_649)) -(assert (>= 1 x_649)) -(assert (<= 0 x_651)) -(assert (>= 1 x_651)) -(assert (<= 0 x_652)) -(assert (>= 1 x_652)) -(assert (<= 0 x_653)) -(assert (>= 1 x_653)) -(assert (<= 0 x_654)) -(assert (>= 1 x_654)) -(assert (<= 0 x_656)) -(assert (>= 1 x_656)) -(assert (<= 0 x_657)) -(assert (>= 1 x_657)) -(assert (<= 0 x_658)) -(assert (>= 1 x_658)) -(assert (<= 0 x_659)) -(assert (>= 1 x_659)) -(assert (<= 0 x_661)) -(assert (>= 1 x_661)) -(assert (<= 0 x_662)) -(assert (>= 1 x_662)) -(assert (<= 0 x_663)) -(assert (>= 1 x_663)) -(assert (<= 0 x_664)) -(assert (>= 1 x_664)) -(assert (<= 0 x_666)) -(assert (>= 1 x_666)) -(assert (<= 0 x_667)) -(assert (>= 1 x_667)) -(assert (<= 0 x_668)) -(assert (>= 1 x_668)) -(assert (<= 0 x_669)) -(assert (>= 1 x_669)) -(assert (<= 0 x_671)) -(assert (>= 1 x_671)) -(assert (<= 0 x_672)) -(assert (>= 1 x_672)) -(assert (<= 0 x_673)) -(assert (>= 1 x_673)) -(assert (<= 0 x_674)) -(assert (>= 1 x_674)) -(assert (<= 0 x_676)) -(assert (>= 1 x_676)) -(assert (<= 0 x_677)) -(assert (>= 1 x_677)) -(assert (<= 0 x_678)) -(assert (>= 1 x_678)) -(assert (<= 0 x_679)) -(assert (>= 1 x_679)) -(assert (<= 0 x_681)) -(assert (>= 1 x_681)) -(assert (<= 0 x_682)) -(assert (>= 1 x_682)) -(assert (<= 0 x_683)) -(assert (>= 1 x_683)) -(assert (<= 0 x_684)) -(assert (>= 1 x_684)) -(assert (<= 0 x_686)) -(assert (>= 1 x_686)) -(assert (<= 0 x_687)) -(assert (>= 1 x_687)) -(assert (<= 0 x_688)) -(assert (>= 1 x_688)) -(assert (<= 0 x_689)) -(assert (>= 1 x_689)) -(assert (<= 0 x_691)) -(assert (>= 1 x_691)) -(assert (<= 0 x_692)) -(assert (>= 1 x_692)) -(assert (<= 0 x_693)) -(assert (>= 1 x_693)) -(assert (<= 0 x_694)) -(assert (>= 1 x_694)) -(assert (<= 0 x_696)) -(assert (>= 1 x_696)) -(assert (<= 0 x_697)) -(assert (>= 1 x_697)) -(assert (<= 0 x_698)) -(assert (>= 1 x_698)) -(assert (<= 0 x_699)) -(assert (>= 1 x_699)) -(assert (<= 0 x_701)) -(assert (>= 1 x_701)) -(assert (<= 0 x_702)) -(assert (>= 1 x_702)) -(assert (<= 0 x_703)) -(assert (>= 1 x_703)) -(assert (<= 0 x_704)) -(assert (>= 1 x_704)) -(assert (<= 0 x_706)) -(assert (>= 1 x_706)) -(assert (<= 0 x_707)) -(assert (>= 1 x_707)) -(assert (<= 0 x_708)) -(assert (>= 1 x_708)) -(assert (<= 0 x_709)) -(assert (>= 1 x_709)) -(assert (<= 0 x_711)) -(assert (>= 1 x_711)) -(assert (<= 0 x_712)) -(assert (>= 1 x_712)) -(assert (<= 0 x_713)) -(assert (>= 1 x_713)) -(assert (<= 0 x_714)) -(assert (>= 1 x_714)) -(assert (<= 0 x_716)) -(assert (>= 1 x_716)) -(assert (<= 0 x_717)) -(assert (>= 1 x_717)) -(assert (<= 0 x_718)) -(assert (>= 1 x_718)) -(assert (<= 0 x_719)) -(assert (>= 1 x_719)) -(assert (<= 0 x_721)) -(assert (>= 1 x_721)) -(assert (<= 0 x_722)) -(assert (>= 1 x_722)) -(assert (<= 0 x_723)) -(assert (>= 1 x_723)) -(assert (<= 0 x_724)) -(assert (>= 1 x_724)) -(assert (<= 0 x_726)) -(assert (>= 1 x_726)) -(assert (<= 0 x_727)) -(assert (>= 1 x_727)) -(assert (<= 0 x_728)) -(assert (>= 1 x_728)) -(assert (<= 0 x_729)) -(assert (>= 1 x_729)) -(assert (<= 0 x_731)) -(assert (>= 1 x_731)) -(assert (<= 0 x_732)) -(assert (>= 1 x_732)) -(assert (<= 0 x_733)) -(assert (>= 1 x_733)) -(assert (<= 0 x_734)) -(assert (>= 1 x_734)) -(assert (<= 0 x_736)) -(assert (>= 1 x_736)) -(assert (<= 0 x_737)) -(assert (>= 1 x_737)) -(assert (<= 0 x_738)) -(assert (>= 1 x_738)) -(assert (<= 0 x_739)) -(assert (>= 1 x_739)) -(assert (<= 0 x_741)) -(assert (>= 1 x_741)) -(assert (<= 0 x_742)) -(assert (>= 1 x_742)) -(assert (<= 0 x_743)) -(assert (>= 1 x_743)) -(assert (<= 0 x_744)) -(assert (>= 1 x_744)) -(assert (<= 0 x_746)) -(assert (>= 1 x_746)) -(assert (<= 0 x_747)) -(assert (>= 1 x_747)) -(assert (<= 0 x_748)) -(assert (>= 1 x_748)) -(assert (<= 0 x_749)) -(assert (>= 1 x_749)) -(assert (<= 0 x_751)) -(assert (>= 1 x_751)) -(assert (<= 0 x_752)) -(assert (>= 1 x_752)) -(assert (<= 0 x_753)) -(assert (>= 1 x_753)) -(assert (<= 0 x_754)) -(assert (>= 1 x_754)) -(assert (<= 0 x_756)) -(assert (>= 1 x_756)) -(assert (<= 0 x_757)) -(assert (>= 1 x_757)) -(assert (<= 0 x_758)) -(assert (>= 1 x_758)) -(assert (<= 0 x_759)) -(assert (>= 1 x_759)) -(assert (<= 0 x_761)) -(assert (>= 1 x_761)) -(assert (<= 0 x_762)) -(assert (>= 1 x_762)) -(assert (<= 0 x_763)) -(assert (>= 1 x_763)) -(assert (<= 0 x_764)) -(assert (>= 1 x_764)) -(assert (<= 0 x_766)) -(assert (>= 1 x_766)) -(assert (<= 0 x_767)) -(assert (>= 1 x_767)) -(assert (<= 0 x_768)) -(assert (>= 1 x_768)) -(assert (<= 0 x_769)) -(assert (>= 1 x_769)) -(assert (<= 0 x_771)) -(assert (>= 1 x_771)) -(assert (<= 0 x_772)) -(assert (>= 1 x_772)) -(assert (<= 0 x_773)) -(assert (>= 1 x_773)) -(assert (<= 0 x_774)) -(assert (>= 1 x_774)) -(assert (<= 0 x_776)) -(assert (>= 1 x_776)) -(assert (<= 0 x_777)) -(assert (>= 1 x_777)) -(assert (<= 0 x_778)) -(assert (>= 1 x_778)) -(assert (<= 0 x_779)) -(assert (>= 1 x_779)) -(assert (<= 0 x_781)) -(assert (>= 1 x_781)) -(assert (<= 0 x_782)) -(assert (>= 1 x_782)) -(assert (<= 0 x_783)) -(assert (>= 1 x_783)) -(assert (<= 0 x_784)) -(assert (>= 1 x_784)) -(assert (<= 0 x_786)) -(assert (>= 1 x_786)) -(assert (<= 0 x_787)) -(assert (>= 1 x_787)) -(assert (<= 0 x_788)) -(assert (>= 1 x_788)) -(assert (<= 0 x_789)) -(assert (>= 1 x_789)) -(assert (<= 0 x_791)) -(assert (>= 1 x_791)) -(assert (<= 0 x_792)) -(assert (>= 1 x_792)) -(assert (<= 0 x_793)) -(assert (>= 1 x_793)) -(assert (<= 0 x_794)) -(assert (>= 1 x_794)) -(assert (<= 0 x_796)) -(assert (>= 1 x_796)) -(assert (<= 0 x_797)) -(assert (>= 1 x_797)) -(assert (<= 0 x_798)) -(assert (>= 1 x_798)) -(assert (<= 0 x_799)) -(assert (>= 1 x_799)) -(assert (<= 0 x_801)) -(assert (>= 1 x_801)) -(assert (<= 0 x_802)) -(assert (>= 1 x_802)) -(assert (<= 0 x_803)) -(assert (>= 1 x_803)) -(assert (<= 0 x_804)) -(assert (>= 1 x_804)) -(assert (<= 0 x_806)) -(assert (>= 1 x_806)) -(assert (<= 0 x_807)) -(assert (>= 1 x_807)) -(assert (<= 0 x_808)) -(assert (>= 1 x_808)) -(assert (<= 0 x_809)) -(assert (>= 1 x_809)) -(assert (<= 0 x_811)) -(assert (>= 1 x_811)) -(assert (<= 0 x_812)) -(assert (>= 1 x_812)) -(assert (<= 0 x_813)) -(assert (>= 1 x_813)) -(assert (<= 0 x_814)) -(assert (>= 1 x_814)) -(assert (<= 0 x_816)) -(assert (>= 1 x_816)) -(assert (<= 0 x_817)) -(assert (>= 1 x_817)) -(assert (<= 0 x_818)) -(assert (>= 1 x_818)) -(assert (<= 0 x_819)) -(assert (>= 1 x_819)) -(assert (<= 0 x_821)) -(assert (>= 1 x_821)) -(assert (<= 0 x_822)) -(assert (>= 1 x_822)) -(assert (<= 0 x_823)) -(assert (>= 1 x_823)) -(assert (<= 0 x_824)) -(assert (>= 1 x_824)) -(assert (<= 0 x_826)) -(assert (>= 1 x_826)) -(assert (<= 0 x_827)) -(assert (>= 1 x_827)) -(assert (<= 0 x_828)) -(assert (>= 1 x_828)) -(assert (<= 0 x_829)) -(assert (>= 1 x_829)) -(assert (<= 0 x_831)) -(assert (>= 1 x_831)) -(assert (<= 0 x_832)) -(assert (>= 1 x_832)) -(assert (<= 0 x_833)) -(assert (>= 1 x_833)) -(assert (<= 0 x_834)) -(assert (>= 1 x_834)) -(assert (<= 0 x_836)) -(assert (>= 1 x_836)) -(assert (<= 0 x_837)) -(assert (>= 1 x_837)) -(assert (<= 0 x_838)) -(assert (>= 1 x_838)) -(assert (<= 0 x_839)) -(assert (>= 1 x_839)) -(assert (<= 0 x_841)) -(assert (>= 1 x_841)) -(assert (<= 0 x_842)) -(assert (>= 1 x_842)) -(assert (<= 0 x_843)) -(assert (>= 1 x_843)) -(assert (<= 0 x_844)) -(assert (>= 1 x_844)) -(assert (<= 0 x_846)) -(assert (>= 1 x_846)) -(assert (<= 0 x_847)) -(assert (>= 1 x_847)) -(assert (<= 0 x_848)) -(assert (>= 1 x_848)) -(assert (<= 0 x_849)) -(assert (>= 1 x_849)) -(assert (<= 0 x_851)) -(assert (>= 1 x_851)) -(assert (<= 0 x_852)) -(assert (>= 1 x_852)) -(assert (<= 0 x_853)) -(assert (>= 1 x_853)) -(assert (<= 0 x_854)) -(assert (>= 1 x_854)) -(assert (<= 0 x_856)) -(assert (>= 1 x_856)) -(assert (<= 0 x_857)) -(assert (>= 1 x_857)) -(assert (<= 0 x_858)) -(assert (>= 1 x_858)) -(assert (<= 0 x_859)) -(assert (>= 1 x_859)) -(assert (<= 0 x_861)) -(assert (>= 1 x_861)) -(assert (<= 0 x_862)) -(assert (>= 1 x_862)) -(assert (<= 0 x_863)) -(assert (>= 1 x_863)) -(assert (<= 0 x_864)) -(assert (>= 1 x_864)) -(assert (<= 0 x_866)) -(assert (>= 1 x_866)) -(assert (<= 0 x_867)) -(assert (>= 1 x_867)) -(assert (<= 0 x_868)) -(assert (>= 1 x_868)) -(assert (<= 0 x_869)) -(assert (>= 1 x_869)) -(assert (<= 0 x_871)) -(assert (>= 1 x_871)) -(assert (<= 0 x_872)) -(assert (>= 1 x_872)) -(assert (<= 0 x_873)) -(assert (>= 1 x_873)) -(assert (<= 0 x_874)) -(assert (>= 1 x_874)) -(assert (<= 0 x_876)) -(assert (>= 1 x_876)) -(assert (<= 0 x_877)) -(assert (>= 1 x_877)) -(assert (<= 0 x_878)) -(assert (>= 1 x_878)) -(assert (<= 0 x_879)) -(assert (>= 1 x_879)) -(assert (<= 0 x_881)) -(assert (>= 1 x_881)) -(assert (<= 0 x_882)) -(assert (>= 1 x_882)) -(assert (<= 0 x_883)) -(assert (>= 1 x_883)) -(assert (<= 0 x_884)) -(assert (>= 1 x_884)) -(assert (<= 0 x_886)) -(assert (>= 1 x_886)) -(assert (<= 0 x_887)) -(assert (>= 1 x_887)) -(assert (<= 0 x_888)) -(assert (>= 1 x_888)) -(assert (<= 0 x_889)) -(assert (>= 1 x_889)) -(assert (<= 0 x_891)) -(assert (>= 1 x_891)) -(assert (<= 0 x_892)) -(assert (>= 1 x_892)) -(assert (<= 0 x_893)) -(assert (>= 1 x_893)) -(assert (<= 0 x_894)) -(assert (>= 1 x_894)) -(assert (<= 0 x_896)) -(assert (>= 1 x_896)) -(assert (<= 0 x_897)) -(assert (>= 1 x_897)) -(assert (<= 0 x_898)) -(assert (>= 1 x_898)) -(assert (<= 0 x_899)) -(assert (>= 1 x_899)) -(assert (<= 0 x_901)) -(assert (>= 1 x_901)) -(assert (<= 0 x_902)) -(assert (>= 1 x_902)) -(assert (<= 0 x_903)) -(assert (>= 1 x_903)) -(assert (<= 0 x_904)) -(assert (>= 1 x_904)) -(assert (<= 0 x_906)) -(assert (>= 1 x_906)) -(assert (<= 0 x_907)) -(assert (>= 1 x_907)) -(assert (<= 0 x_908)) -(assert (>= 1 x_908)) -(assert (<= 0 x_909)) -(assert (>= 1 x_909)) -(assert (<= 0 x_911)) -(assert (>= 1 x_911)) -(assert (<= 0 x_912)) -(assert (>= 1 x_912)) -(assert (<= 0 x_913)) -(assert (>= 1 x_913)) -(assert (<= 0 x_914)) -(assert (>= 1 x_914)) -(assert (<= 0 x_916)) -(assert (>= 1 x_916)) -(assert (<= 0 x_917)) -(assert (>= 1 x_917)) -(assert (<= 0 x_918)) -(assert (>= 1 x_918)) -(assert (<= 0 x_919)) -(assert (>= 1 x_919)) -(assert (<= 0 x_921)) -(assert (>= 1 x_921)) -(assert (<= 0 x_922)) -(assert (>= 1 x_922)) -(assert (<= 0 x_923)) -(assert (>= 1 x_923)) -(assert (<= 0 x_924)) -(assert (>= 1 x_924)) -(assert (<= 0 x_926)) -(assert (>= 1 x_926)) -(assert (<= 0 x_927)) -(assert (>= 1 x_927)) -(assert (<= 0 x_928)) -(assert (>= 1 x_928)) -(assert (<= 0 x_929)) -(assert (>= 1 x_929)) -(assert (<= 0 x_931)) -(assert (>= 1 x_931)) -(assert (<= 0 x_932)) -(assert (>= 1 x_932)) -(assert (<= 0 x_933)) -(assert (>= 1 x_933)) -(assert (<= 0 x_934)) -(assert (>= 1 x_934)) -(assert (<= 0 x_936)) -(assert (>= 1 x_936)) -(assert (<= 0 x_937)) -(assert (>= 1 x_937)) -(assert (<= 0 x_938)) -(assert (>= 1 x_938)) -(assert (<= 0 x_939)) -(assert (>= 1 x_939)) -(assert (<= 0 x_941)) -(assert (>= 1 x_941)) -(assert (<= 0 x_942)) -(assert (>= 1 x_942)) -(assert (<= 0 x_943)) -(assert (>= 1 x_943)) -(assert (<= 0 x_944)) -(assert (>= 1 x_944)) -(assert (<= 0 x_946)) -(assert (>= 1 x_946)) -(assert (<= 0 x_947)) -(assert (>= 1 x_947)) -(assert (<= 0 x_948)) -(assert (>= 1 x_948)) -(assert (<= 0 x_949)) -(assert (>= 1 x_949)) -(assert (<= 0 x_951)) -(assert (>= 1 x_951)) -(assert (<= 0 x_952)) -(assert (>= 1 x_952)) -(assert (<= 0 x_953)) -(assert (>= 1 x_953)) -(assert (<= 0 x_954)) -(assert (>= 1 x_954)) -(assert (<= 0 x_956)) -(assert (>= 1 x_956)) -(assert (<= 0 x_957)) -(assert (>= 1 x_957)) -(assert (<= 0 x_958)) -(assert (>= 1 x_958)) -(assert (<= 0 x_959)) -(assert (>= 1 x_959)) -(assert (<= 0 x_961)) -(assert (>= 1 x_961)) -(assert (<= 0 x_962)) -(assert (>= 1 x_962)) -(assert (<= 0 x_963)) -(assert (>= 1 x_963)) -(assert (<= 0 x_964)) -(assert (>= 1 x_964)) -(assert (<= 0 x_966)) -(assert (>= 1 x_966)) -(assert (<= 0 x_967)) -(assert (>= 1 x_967)) -(assert (<= 0 x_968)) -(assert (>= 1 x_968)) -(assert (<= 0 x_969)) -(assert (>= 1 x_969)) -(assert (<= 0 x_971)) -(assert (>= 1 x_971)) -(assert (<= 0 x_972)) -(assert (>= 1 x_972)) -(assert (<= 0 x_973)) -(assert (>= 1 x_973)) -(assert (<= 0 x_974)) -(assert (>= 1 x_974)) -(assert (<= 0 x_976)) -(assert (>= 1 x_976)) -(assert (<= 0 x_977)) -(assert (>= 1 x_977)) -(assert (<= 0 x_978)) -(assert (>= 1 x_978)) -(assert (<= 0 x_979)) -(assert (>= 1 x_979)) -(assert (<= 0 x_981)) -(assert (>= 1 x_981)) -(assert (<= 0 x_982)) -(assert (>= 1 x_982)) -(assert (<= 0 x_983)) -(assert (>= 1 x_983)) -(assert (<= 0 x_984)) -(assert (>= 1 x_984)) -(assert (<= 0 x_986)) -(assert (>= 1 x_986)) -(assert (<= 0 x_987)) -(assert (>= 1 x_987)) -(assert (<= 0 x_988)) -(assert (>= 1 x_988)) -(assert (<= 0 x_989)) -(assert (>= 1 x_989)) -(assert (<= 0 x_991)) -(assert (>= 1 x_991)) -(assert (<= 0 x_992)) -(assert (>= 1 x_992)) -(assert (<= 0 x_993)) -(assert (>= 1 x_993)) -(assert (<= 0 x_994)) -(assert (>= 1 x_994)) -(assert (<= 0 x_996)) -(assert (>= 1 x_996)) -(assert (<= 0 x_997)) -(assert (>= 1 x_997)) -(assert (<= 0 x_998)) -(assert (>= 1 x_998)) -(assert (<= 0 x_999)) -(assert (>= 1 x_999)) -(assert (<= 0 x_1001)) -(assert (>= 1 x_1001)) -(assert (<= 0 x_1202)) -(assert (>= 1 x_1202)) -(assert (<= 0 x_1403)) -(assert (>= 1 x_1403)) -(assert (<= 0 x_1604)) -(assert (>= 1 x_1604)) -(assert (= 1 (+ x_1 x_2 x_3 x_4))) -(assert (= 1 (+ x_6 x_7 x_8 x_9))) -(assert (= 1 (+ x_11 x_12 x_13 x_14))) -(assert (= 1 (+ x_16 x_17 x_18 x_19))) -(assert (= 1 (+ x_21 x_22 x_23 x_24))) -(assert (= 1 (+ x_26 x_27 x_28 x_29))) -(assert (= 1 (+ x_31 x_32 x_33 x_34))) -(assert (= 1 (+ x_36 x_37 x_38 x_39))) -(assert (= 1 (+ x_41 x_42 x_43 x_44))) -(assert (= 1 (+ x_46 x_47 x_48 x_49))) -(assert (= 1 (+ x_51 x_52 x_53 x_54))) -(assert (= 1 (+ x_56 x_57 x_58 x_59))) -(assert (= 1 (+ x_61 x_62 x_63 x_64))) -(assert (= 1 (+ x_66 x_67 x_68 x_69))) -(assert (= 1 (+ x_71 x_72 x_73 x_74))) -(assert (= 1 (+ x_76 x_77 x_78 x_79))) -(assert (= 1 (+ x_81 x_82 x_83 x_84))) -(assert (= 1 (+ x_86 x_87 x_88 x_89))) -(assert (= 1 (+ x_91 x_92 x_93 x_94))) -(assert (= 1 (+ x_96 x_97 x_98 x_99))) -(assert (= 1 (+ x_101 x_102 x_103 x_104))) -(assert (= 1 (+ x_106 x_107 x_108 x_109))) -(assert (= 1 (+ x_111 x_112 x_113 x_114))) -(assert (= 1 (+ x_116 x_117 x_118 x_119))) -(assert (= 1 (+ x_121 x_122 x_123 x_124))) -(assert (= 1 (+ x_126 x_127 x_128 x_129))) -(assert (= 1 (+ x_131 x_132 x_133 x_134))) -(assert (= 1 (+ x_136 x_137 x_138 x_139))) -(assert (= 1 (+ x_141 x_142 x_143 x_144))) -(assert (= 1 (+ x_146 x_147 x_148 x_149))) -(assert (= 1 (+ x_151 x_152 x_153 x_154))) -(assert (= 1 (+ x_156 x_157 x_158 x_159))) -(assert (= 1 (+ x_161 x_162 x_163 x_164))) -(assert (= 1 (+ x_166 x_167 x_168 x_169))) -(assert (= 1 (+ x_171 x_172 x_173 x_174))) -(assert (= 1 (+ x_176 x_177 x_178 x_179))) -(assert (= 1 (+ x_181 x_182 x_183 x_184))) -(assert (= 1 (+ x_186 x_187 x_188 x_189))) -(assert (= 1 (+ x_191 x_192 x_193 x_194))) -(assert (= 1 (+ x_196 x_197 x_198 x_199))) -(assert (= 1 (+ x_201 x_202 x_203 x_204))) -(assert (= 1 (+ x_206 x_207 x_208 x_209))) -(assert (= 1 (+ x_211 x_212 x_213 x_214))) -(assert (= 1 (+ x_216 x_217 x_218 x_219))) -(assert (= 1 (+ x_221 x_222 x_223 x_224))) -(assert (= 1 (+ x_226 x_227 x_228 x_229))) -(assert (= 1 (+ x_231 x_232 x_233 x_234))) -(assert (= 1 (+ x_236 x_237 x_238 x_239))) -(assert (= 1 (+ x_241 x_242 x_243 x_244))) -(assert (= 1 (+ x_246 x_247 x_248 x_249))) -(assert (= 1 (+ x_251 x_252 x_253 x_254))) -(assert (= 1 (+ x_256 x_257 x_258 x_259))) -(assert (= 1 (+ x_261 x_262 x_263 x_264))) -(assert (= 1 (+ x_266 x_267 x_268 x_269))) -(assert (= 1 (+ x_271 x_272 x_273 x_274))) -(assert (= 1 (+ x_276 x_277 x_278 x_279))) -(assert (= 1 (+ x_281 x_282 x_283 x_284))) -(assert (= 1 (+ x_286 x_287 x_288 x_289))) -(assert (= 1 (+ x_291 x_292 x_293 x_294))) -(assert (= 1 (+ x_296 x_297 x_298 x_299))) -(assert (= 1 (+ x_301 x_302 x_303 x_304))) -(assert (= 1 (+ x_306 x_307 x_308 x_309))) -(assert (= 1 (+ x_311 x_312 x_313 x_314))) -(assert (= 1 (+ x_316 x_317 x_318 x_319))) -(assert (= 1 (+ x_321 x_322 x_323 x_324))) -(assert (= 1 (+ x_326 x_327 x_328 x_329))) -(assert (= 1 (+ x_331 x_332 x_333 x_334))) -(assert (= 1 (+ x_336 x_337 x_338 x_339))) -(assert (= 1 (+ x_341 x_342 x_343 x_344))) -(assert (= 1 (+ x_346 x_347 x_348 x_349))) -(assert (= 1 (+ x_351 x_352 x_353 x_354))) -(assert (= 1 (+ x_356 x_357 x_358 x_359))) -(assert (= 1 (+ x_361 x_362 x_363 x_364))) -(assert (= 1 (+ x_366 x_367 x_368 x_369))) -(assert (= 1 (+ x_371 x_372 x_373 x_374))) -(assert (= 1 (+ x_376 x_377 x_378 x_379))) -(assert (= 1 (+ x_381 x_382 x_383 x_384))) -(assert (= 1 (+ x_386 x_387 x_388 x_389))) -(assert (= 1 (+ x_391 x_392 x_393 x_394))) -(assert (= 1 (+ x_396 x_397 x_398 x_399))) -(assert (= 1 (+ x_401 x_402 x_403 x_404))) -(assert (= 1 (+ x_406 x_407 x_408 x_409))) -(assert (= 1 (+ x_411 x_412 x_413 x_414))) -(assert (= 1 (+ x_416 x_417 x_418 x_419))) -(assert (= 1 (+ x_421 x_422 x_423 x_424))) -(assert (= 1 (+ x_426 x_427 x_428 x_429))) -(assert (= 1 (+ x_431 x_432 x_433 x_434))) -(assert (= 1 (+ x_436 x_437 x_438 x_439))) -(assert (= 1 (+ x_441 x_442 x_443 x_444))) -(assert (= 1 (+ x_446 x_447 x_448 x_449))) -(assert (= 1 (+ x_451 x_452 x_453 x_454))) -(assert (= 1 (+ x_456 x_457 x_458 x_459))) -(assert (= 1 (+ x_461 x_462 x_463 x_464))) -(assert (= 1 (+ x_466 x_467 x_468 x_469))) -(assert (= 1 (+ x_471 x_472 x_473 x_474))) -(assert (= 1 (+ x_476 x_477 x_478 x_479))) -(assert (= 1 (+ x_481 x_482 x_483 x_484))) -(assert (= 1 (+ x_486 x_487 x_488 x_489))) -(assert (= 1 (+ x_491 x_492 x_493 x_494))) -(assert (= 1 (+ x_496 x_497 x_498 x_499))) -(assert (= 1 (+ x_501 x_502 x_503 x_504))) -(assert (= 1 (+ x_506 x_507 x_508 x_509))) -(assert (= 1 (+ x_511 x_512 x_513 x_514))) -(assert (= 1 (+ x_516 x_517 x_518 x_519))) -(assert (= 1 (+ x_521 x_522 x_523 x_524))) -(assert (= 1 (+ x_526 x_527 x_528 x_529))) -(assert (= 1 (+ x_531 x_532 x_533 x_534))) -(assert (= 1 (+ x_536 x_537 x_538 x_539))) -(assert (= 1 (+ x_541 x_542 x_543 x_544))) -(assert (= 1 (+ x_546 x_547 x_548 x_549))) -(assert (= 1 (+ x_551 x_552 x_553 x_554))) -(assert (= 1 (+ x_556 x_557 x_558 x_559))) -(assert (= 1 (+ x_561 x_562 x_563 x_564))) -(assert (= 1 (+ x_566 x_567 x_568 x_569))) -(assert (= 1 (+ x_571 x_572 x_573 x_574))) -(assert (= 1 (+ x_576 x_577 x_578 x_579))) -(assert (= 1 (+ x_581 x_582 x_583 x_584))) -(assert (= 1 (+ x_586 x_587 x_588 x_589))) -(assert (= 1 (+ x_591 x_592 x_593 x_594))) -(assert (= 1 (+ x_596 x_597 x_598 x_599))) -(assert (= 1 (+ x_601 x_602 x_603 x_604))) -(assert (= 1 (+ x_606 x_607 x_608 x_609))) -(assert (= 1 (+ x_611 x_612 x_613 x_614))) -(assert (= 1 (+ x_616 x_617 x_618 x_619))) -(assert (= 1 (+ x_621 x_622 x_623 x_624))) -(assert (= 1 (+ x_626 x_627 x_628 x_629))) -(assert (= 1 (+ x_631 x_632 x_633 x_634))) -(assert (= 1 (+ x_636 x_637 x_638 x_639))) -(assert (= 1 (+ x_641 x_642 x_643 x_644))) -(assert (= 1 (+ x_646 x_647 x_648 x_649))) -(assert (= 1 (+ x_651 x_652 x_653 x_654))) -(assert (= 1 (+ x_656 x_657 x_658 x_659))) -(assert (= 1 (+ x_661 x_662 x_663 x_664))) -(assert (= 1 (+ x_666 x_667 x_668 x_669))) -(assert (= 1 (+ x_671 x_672 x_673 x_674))) -(assert (= 1 (+ x_676 x_677 x_678 x_679))) -(assert (= 1 (+ x_681 x_682 x_683 x_684))) -(assert (= 1 (+ x_686 x_687 x_688 x_689))) -(assert (= 1 (+ x_691 x_692 x_693 x_694))) -(assert (= 1 (+ x_696 x_697 x_698 x_699))) -(assert (= 1 (+ x_701 x_702 x_703 x_704))) -(assert (= 1 (+ x_706 x_707 x_708 x_709))) -(assert (= 1 (+ x_711 x_712 x_713 x_714))) -(assert (= 1 (+ x_716 x_717 x_718 x_719))) -(assert (= 1 (+ x_721 x_722 x_723 x_724))) -(assert (= 1 (+ x_726 x_727 x_728 x_729))) -(assert (= 1 (+ x_731 x_732 x_733 x_734))) -(assert (= 1 (+ x_736 x_737 x_738 x_739))) -(assert (= 1 (+ x_741 x_742 x_743 x_744))) -(assert (= 1 (+ x_746 x_747 x_748 x_749))) -(assert (= 1 (+ x_751 x_752 x_753 x_754))) -(assert (= 1 (+ x_756 x_757 x_758 x_759))) -(assert (= 1 (+ x_761 x_762 x_763 x_764))) -(assert (= 1 (+ x_766 x_767 x_768 x_769))) -(assert (= 1 (+ x_771 x_772 x_773 x_774))) -(assert (= 1 (+ x_776 x_777 x_778 x_779))) -(assert (= 1 (+ x_781 x_782 x_783 x_784))) -(assert (= 1 (+ x_786 x_787 x_788 x_789))) -(assert (= 1 (+ x_791 x_792 x_793 x_794))) -(assert (= 1 (+ x_796 x_797 x_798 x_799))) -(assert (= 1 (+ x_801 x_802 x_803 x_804))) -(assert (= 1 (+ x_806 x_807 x_808 x_809))) -(assert (= 1 (+ x_811 x_812 x_813 x_814))) -(assert (= 1 (+ x_816 x_817 x_818 x_819))) -(assert (= 1 (+ x_821 x_822 x_823 x_824))) -(assert (= 1 (+ x_826 x_827 x_828 x_829))) -(assert (= 1 (+ x_831 x_832 x_833 x_834))) -(assert (= 1 (+ x_836 x_837 x_838 x_839))) -(assert (= 1 (+ x_841 x_842 x_843 x_844))) -(assert (= 1 (+ x_846 x_847 x_848 x_849))) -(assert (= 1 (+ x_851 x_852 x_853 x_854))) -(assert (= 1 (+ x_856 x_857 x_858 x_859))) -(assert (= 1 (+ x_861 x_862 x_863 x_864))) -(assert (= 1 (+ x_866 x_867 x_868 x_869))) -(assert (= 1 (+ x_871 x_872 x_873 x_874))) -(assert (= 1 (+ x_876 x_877 x_878 x_879))) -(assert (= 1 (+ x_881 x_882 x_883 x_884))) -(assert (= 1 (+ x_886 x_887 x_888 x_889))) -(assert (= 1 (+ x_891 x_892 x_893 x_894))) -(assert (= 1 (+ x_896 x_897 x_898 x_899))) -(assert (= 1 (+ x_901 x_902 x_903 x_904))) -(assert (= 1 (+ x_906 x_907 x_908 x_909))) -(assert (= 1 (+ x_911 x_912 x_913 x_914))) -(assert (= 1 (+ x_916 x_917 x_918 x_919))) -(assert (= 1 (+ x_921 x_922 x_923 x_924))) -(assert (= 1 (+ x_926 x_927 x_928 x_929))) -(assert (= 1 (+ x_931 x_932 x_933 x_934))) -(assert (= 1 (+ x_936 x_937 x_938 x_939))) -(assert (= 1 (+ x_941 x_942 x_943 x_944))) -(assert (= 1 (+ x_946 x_947 x_948 x_949))) -(assert (= 1 (+ x_951 x_952 x_953 x_954))) -(assert (= 1 (+ x_956 x_957 x_958 x_959))) -(assert (= 1 (+ x_961 x_962 x_963 x_964))) -(assert (= 1 (+ x_966 x_967 x_968 x_969))) -(assert (= 1 (+ x_971 x_972 x_973 x_974))) -(assert (= 1 (+ x_976 x_977 x_978 x_979))) -(assert (= 1 (+ x_981 x_982 x_983 x_984))) -(assert (= 1 (+ x_986 x_987 x_988 x_989))) -(assert (= 1 (+ x_991 x_992 x_993 x_994))) -(assert (= 1 (+ x_996 x_997 x_998 x_999))) -(assert (<= 0 (+ x_1001 (* (- 1) x_4)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_9)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_14)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_19)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_24)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_29)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_34)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_39)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_44)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_49)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_54)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_59)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_64)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_69)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_74)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_79)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_84)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_89)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_94)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_99)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_104)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_109)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_114)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_119)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_124)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_129)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_134)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_139)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_144)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_149)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_154)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_159)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_164)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_169)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_174)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_179)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_184)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_189)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_194)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_199)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_204)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_209)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_214)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_219)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_224)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_229)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_234)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_239)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_244)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_249)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_254)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_259)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_264)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_269)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_274)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_279)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_284)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_289)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_294)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_299)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_304)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_309)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_314)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_319)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_324)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_329)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_334)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_339)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_344)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_349)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_354)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_359)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_364)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_369)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_374)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_379)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_384)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_389)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_394)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_399)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_404)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_409)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_414)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_419)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_424)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_429)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_434)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_439)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_444)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_449)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_454)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_459)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_464)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_469)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_474)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_479)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_484)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_489)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_494)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_499)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_504)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_509)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_514)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_519)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_524)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_529)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_534)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_539)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_544)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_549)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_554)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_559)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_564)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_569)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_574)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_579)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_584)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_589)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_594)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_599)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_604)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_609)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_614)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_619)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_624)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_629)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_634)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_639)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_644)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_649)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_654)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_659)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_664)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_669)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_674)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_679)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_684)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_689)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_694)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_699)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_704)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_709)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_714)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_719)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_724)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_729)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_734)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_739)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_744)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_749)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_754)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_759)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_764)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_769)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_774)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_779)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_784)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_789)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_794)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_799)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_804)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_809)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_814)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_819)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_824)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_829)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_834)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_839)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_844)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_849)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_854)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_859)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_864)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_869)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_874)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_879)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_884)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_889)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_894)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_899)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_904)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_909)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_914)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_919)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_924)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_929)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_934)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_939)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_944)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_949)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_954)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_959)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_964)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_969)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_974)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_979)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_984)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_989)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_994)))) -(assert (<= 0 (+ x_1001 (* (- 1) x_999)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_1)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_6)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_11)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_16)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_21)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_26)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_31)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_36)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_41)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_46)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_51)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_56)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_61)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_66)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_71)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_76)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_81)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_86)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_91)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_96)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_101)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_106)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_111)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_116)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_121)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_126)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_131)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_136)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_141)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_146)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_151)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_156)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_161)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_166)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_171)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_176)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_181)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_186)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_191)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_196)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_201)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_206)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_211)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_216)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_221)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_226)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_231)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_236)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_241)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_246)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_251)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_256)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_261)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_266)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_271)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_276)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_281)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_286)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_291)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_296)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_301)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_306)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_311)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_316)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_321)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_326)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_331)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_336)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_341)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_346)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_351)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_356)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_361)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_366)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_371)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_376)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_381)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_386)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_391)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_396)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_401)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_406)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_411)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_416)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_421)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_426)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_431)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_436)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_441)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_446)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_451)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_456)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_461)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_466)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_471)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_476)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_481)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_486)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_491)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_496)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_501)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_506)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_511)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_516)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_521)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_526)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_531)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_536)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_541)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_546)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_551)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_556)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_561)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_566)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_571)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_576)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_581)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_586)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_591)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_596)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_601)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_606)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_611)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_616)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_621)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_626)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_631)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_636)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_641)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_646)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_651)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_656)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_661)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_666)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_671)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_676)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_681)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_686)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_691)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_696)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_701)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_706)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_711)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_716)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_721)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_726)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_731)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_736)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_741)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_746)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_751)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_756)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_761)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_766)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_771)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_776)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_781)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_786)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_791)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_796)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_801)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_806)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_811)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_816)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_821)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_826)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_831)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_836)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_841)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_846)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_851)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_856)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_861)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_866)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_871)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_876)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_881)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_886)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_891)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_896)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_901)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_906)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_911)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_916)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_921)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_926)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_931)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_936)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_941)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_946)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_951)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_956)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_961)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_966)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_971)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_976)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_981)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_986)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_991)))) -(assert (<= 0 (+ x_1202 (* (- 1) x_996)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_2)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_7)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_12)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_17)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_22)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_27)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_32)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_37)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_42)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_47)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_52)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_57)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_62)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_67)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_72)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_77)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_82)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_87)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_92)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_97)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_102)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_107)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_112)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_117)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_122)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_127)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_132)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_137)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_142)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_147)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_152)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_157)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_162)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_167)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_172)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_177)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_182)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_187)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_192)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_197)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_202)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_207)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_212)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_217)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_222)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_227)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_232)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_237)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_242)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_247)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_252)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_257)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_262)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_267)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_272)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_277)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_282)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_287)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_292)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_297)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_302)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_307)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_312)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_317)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_322)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_327)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_332)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_337)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_342)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_347)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_352)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_357)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_362)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_367)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_372)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_377)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_382)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_387)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_392)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_397)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_402)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_407)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_412)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_417)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_422)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_427)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_432)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_437)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_442)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_447)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_452)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_457)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_462)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_467)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_472)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_477)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_482)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_487)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_492)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_497)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_502)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_507)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_512)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_517)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_522)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_527)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_532)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_537)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_542)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_547)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_552)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_557)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_562)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_567)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_572)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_577)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_582)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_587)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_592)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_597)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_602)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_607)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_612)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_617)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_622)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_627)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_632)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_637)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_642)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_647)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_652)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_657)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_662)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_667)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_672)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_677)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_682)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_687)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_692)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_697)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_702)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_707)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_712)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_717)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_722)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_727)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_732)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_737)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_742)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_747)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_752)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_757)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_762)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_767)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_772)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_777)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_782)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_787)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_792)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_797)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_802)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_807)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_812)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_817)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_822)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_827)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_832)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_837)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_842)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_847)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_852)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_857)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_862)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_867)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_872)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_877)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_882)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_887)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_892)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_897)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_902)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_907)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_912)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_917)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_922)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_927)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_932)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_937)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_942)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_947)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_952)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_957)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_962)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_967)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_972)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_977)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_982)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_987)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_992)))) -(assert (<= 0 (+ x_1403 (* (- 1) x_997)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_3)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_8)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_13)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_18)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_23)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_28)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_33)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_38)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_43)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_48)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_53)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_58)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_63)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_68)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_73)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_78)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_83)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_88)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_93)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_98)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_103)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_108)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_113)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_118)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_123)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_128)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_133)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_138)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_143)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_148)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_153)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_158)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_163)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_168)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_173)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_178)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_183)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_188)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_193)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_198)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_203)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_208)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_213)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_218)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_223)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_228)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_233)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_238)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_243)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_248)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_253)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_258)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_263)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_268)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_273)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_278)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_283)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_288)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_293)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_298)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_303)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_308)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_313)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_318)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_323)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_328)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_333)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_338)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_343)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_348)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_353)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_358)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_363)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_368)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_373)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_378)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_383)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_388)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_393)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_398)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_403)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_408)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_413)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_418)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_423)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_428)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_433)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_438)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_443)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_448)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_453)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_458)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_463)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_468)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_473)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_478)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_483)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_488)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_493)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_498)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_503)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_508)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_513)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_518)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_523)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_528)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_533)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_538)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_543)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_548)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_553)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_558)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_563)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_568)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_573)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_578)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_583)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_588)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_593)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_598)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_603)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_608)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_613)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_618)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_623)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_628)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_633)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_638)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_643)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_648)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_653)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_658)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_663)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_668)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_673)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_678)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_683)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_688)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_693)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_698)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_703)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_708)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_713)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_718)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_723)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_728)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_733)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_738)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_743)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_748)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_753)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_758)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_763)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_768)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_773)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_778)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_783)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_788)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_793)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_798)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_803)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_808)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_813)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_818)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_823)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_828)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_833)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_838)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_843)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_848)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_853)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_858)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_863)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_868)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_873)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_878)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_883)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_888)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_893)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_898)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_903)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_908)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_913)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_918)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_923)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_928)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_933)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_938)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_943)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_948)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_953)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_958)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_963)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_968)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_973)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_978)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_983)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_988)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_993)))) -(assert (<= 0 (+ x_1604 (* (- 1) x_998)))) -(assert (<= 0 - (+ (* 21600 x_1001) - (* (- 50) x_9) - (* (- 40) x_14) - (* (- 50) x_19) - (* (- 60) x_24) - (* (- 40) x_29) - (* (- 40) x_34) - (* (- 50) x_39) - (* (- 40) x_44) - (* (- 40) x_49) - (* (- 40) x_54) - (* (- 50) x_59) - (* (- 40) x_64) - (* (- 40) x_69) - (* (- 50) x_74) - (* (- 60) x_79) - (* (- 70) x_84) - (* (- 80) x_89) - (* (- 90) x_94) - (* (- 100) x_99) - (* (- 40) x_104) - (* (- 50) x_109) - (* (- 60) x_114) - (* (- 70) x_119) - (* (- 40) x_124) - (* (- 50) x_129) - (* (- 60) x_134) - (* (- 70) x_139) - (* (- 80) x_144) - (* (- 90) x_149) - (* (- 100) x_154) - (* (- 110) x_159) - (* (- 120) x_164) - (* (- 40) x_169) - (* (- 50) x_174) - (* (- 60) x_179) - (* (- 70) x_184) - (* (- 40) x_189) - (* (- 50) x_194) - (* (- 60) x_199) - (* (- 40) x_204) - (* (- 50) x_209) - (* (- 40) x_214) - (* (- 50) x_219) - (* (- 60) x_224) - (* (- 70) x_229) - (* (- 80) x_234) - (* (- 90) x_239) - (* (- 100) x_244) - (* (- 110) x_249) - (* (- 40) x_254) - (* (- 50) x_259) - (* (- 60) x_264) - (* (- 70) x_269) - (* (- 80) x_274) - (* (- 90) x_279) - (* (- 100) x_284) - (* (- 40) x_289) - (* (- 50) x_294) - (* (- 60) x_299) - (* (- 70) x_304) - (* (- 80) x_309) - (* (- 90) x_314) - (* (- 100) x_319) - (* (- 110) x_324) - (* (- 40) x_329) - (* (- 50) x_334) - (* (- 60) x_339) - (* (- 70) x_344) - (* (- 80) x_349) - (* (- 90) x_354) - (* (- 100) x_359) - (* (- 40) x_364) - (* (- 50) x_369) - (* (- 60) x_374) - (* (- 70) x_379) - (* (- 80) x_384) - (* (- 90) x_389) - (* (- 100) x_394) - (* (- 40) x_399) - (* (- 50) x_404) - (* (- 60) x_409) - (* (- 40) x_414) - (* (- 50) x_419) - (* (- 60) x_424) - (* (- 70) x_429) - (* (- 80) x_434) - (* (- 90) x_439) - (* (- 100) x_444) - (* (- 110) x_449) - (* (- 120) x_454) - (* (- 130) x_459) - (* (- 40) x_464) - (* (- 50) x_469) - (* (- 60) x_474) - (* (- 70) x_479) - (* (- 80) x_484) - (* (- 90) x_489) - (* (- 40) x_494) - (* (- 40) x_499) - (* (- 50) x_504) - (* (- 60) x_509) - (* (- 70) x_514) - (* (- 80) x_519) - (* (- 90) x_524) - (* (- 40) x_529) - (* (- 50) x_534) - (* (- 60) x_539) - (* (- 40) x_544) - (* (- 50) x_549) - (* (- 60) x_554) - (* (- 70) x_559) - (* (- 40) x_564) - (* (- 50) x_569) - (* (- 60) x_574) - (* (- 70) x_579) - (* (- 80) x_584) - (* (- 90) x_589) - (* (- 40) x_594) - (* (- 40) x_599) - (* (- 50) x_604) - (* (- 60) x_609) - (* (- 70) x_614) - (* (- 80) x_619) - (* (- 40) x_624) - (* (- 50) x_629) - (* (- 60) x_634) - (* (- 70) x_639) - (* (- 80) x_644) - (* (- 90) x_649) - (* (- 100) x_654) - (* (- 110) x_659) - (* (- 40) x_664) - (* (- 50) x_669) - (* (- 60) x_674) - (* (- 70) x_679) - (* (- 40) x_684) - (* (- 50) x_689) - (* (- 60) x_694) - (* (- 70) x_699) - (* (- 80) x_704) - (* (- 90) x_709) - (* (- 100) x_714) - (* (- 110) x_719) - (* (- 120) x_724) - (* (- 40) x_729) - (* (- 50) x_734) - (* (- 60) x_739) - (* (- 70) x_744) - (* (- 80) x_749) - (* (- 90) x_754) - (* (- 100) x_759) - (* (- 110) x_764) - (* (- 40) x_769) - (* (- 50) x_774) - (* (- 40) x_779) - (* (- 50) x_784) - (* (- 40) x_789) - (* (- 50) x_794) - (* (- 60) x_799) - (* (- 70) x_804) - (* (- 80) x_809) - (* (- 90) x_814) - (* (- 100) x_819) - (* (- 40) x_824) - (* (- 50) x_829) - (* (- 60) x_834) - (* (- 70) x_839) - (* (- 80) x_844) - (* (- 90) x_849) - (* (- 100) x_854) - (* (- 110) x_859) - (* (- 40) x_864) - (* (- 50) x_869) - (* (- 60) x_874) - (* (- 70) x_879) - (* (- 80) x_884) - (* (- 90) x_889) - (* (- 40) x_894) - (* (- 50) x_899) - (* (- 60) x_904) - (* (- 70) x_909) - (* (- 80) x_914) - (* (- 90) x_919) - (* (- 100) x_924) - (* (- 52) x_929) - (* (- 52) x_934) - (* (- 65) x_939) - (* (- 52) x_944) - (* (- 52) x_949) - (* (- 65) x_954) - (* (- 52) x_959) - (* (- 65) x_964) - (* (- 52) x_969) - (* (- 65) x_974) - (* (- 78) x_979) - (* (- 91) x_984) - (* (- 104) x_989) - (* (- 117) x_994) - (* (- 130) x_999) - (* (- 40) x_4)))) -(assert (<= 0 - (+ (* 7400 x_1202) - (* (- 50) x_6) - (* (- 40) x_11) - (* (- 50) x_16) - (* (- 60) x_21) - (* (- 40) x_26) - (* (- 40) x_31) - (* (- 50) x_36) - (* (- 40) x_41) - (* (- 40) x_46) - (* (- 40) x_51) - (* (- 50) x_56) - (* (- 40) x_61) - (* (- 40) x_66) - (* (- 50) x_71) - (* (- 60) x_76) - (* (- 70) x_81) - (* (- 80) x_86) - (* (- 90) x_91) - (* (- 100) x_96) - (* (- 40) x_101) - (* (- 50) x_106) - (* (- 60) x_111) - (* (- 70) x_116) - (* (- 40) x_121) - (* (- 50) x_126) - (* (- 60) x_131) - (* (- 70) x_136) - (* (- 80) x_141) - (* (- 90) x_146) - (* (- 100) x_151) - (* (- 110) x_156) - (* (- 120) x_161) - (* (- 40) x_166) - (* (- 50) x_171) - (* (- 60) x_176) - (* (- 70) x_181) - (* (- 40) x_186) - (* (- 50) x_191) - (* (- 60) x_196) - (* (- 40) x_201) - (* (- 50) x_206) - (* (- 40) x_211) - (* (- 50) x_216) - (* (- 60) x_221) - (* (- 70) x_226) - (* (- 80) x_231) - (* (- 90) x_236) - (* (- 100) x_241) - (* (- 110) x_246) - (* (- 40) x_251) - (* (- 50) x_256) - (* (- 60) x_261) - (* (- 70) x_266) - (* (- 80) x_271) - (* (- 90) x_276) - (* (- 100) x_281) - (* (- 40) x_286) - (* (- 50) x_291) - (* (- 60) x_296) - (* (- 70) x_301) - (* (- 80) x_306) - (* (- 90) x_311) - (* (- 100) x_316) - (* (- 110) x_321) - (* (- 40) x_326) - (* (- 50) x_331) - (* (- 60) x_336) - (* (- 70) x_341) - (* (- 80) x_346) - (* (- 90) x_351) - (* (- 100) x_356) - (* (- 40) x_361) - (* (- 50) x_366) - (* (- 60) x_371) - (* (- 70) x_376) - (* (- 80) x_381) - (* (- 90) x_386) - (* (- 100) x_391) - (* (- 40) x_396) - (* (- 50) x_401) - (* (- 60) x_406) - (* (- 40) x_411) - (* (- 50) x_416) - (* (- 60) x_421) - (* (- 70) x_426) - (* (- 80) x_431) - (* (- 90) x_436) - (* (- 100) x_441) - (* (- 110) x_446) - (* (- 120) x_451) - (* (- 130) x_456) - (* (- 40) x_461) - (* (- 50) x_466) - (* (- 60) x_471) - (* (- 70) x_476) - (* (- 80) x_481) - (* (- 90) x_486) - (* (- 40) x_491) - (* (- 40) x_496) - (* (- 50) x_501) - (* (- 60) x_506) - (* (- 70) x_511) - (* (- 80) x_516) - (* (- 90) x_521) - (* (- 40) x_526) - (* (- 50) x_531) - (* (- 60) x_536) - (* (- 40) x_541) - (* (- 50) x_546) - (* (- 60) x_551) - (* (- 70) x_556) - (* (- 40) x_561) - (* (- 50) x_566) - (* (- 60) x_571) - (* (- 70) x_576) - (* (- 80) x_581) - (* (- 90) x_586) - (* (- 40) x_591) - (* (- 40) x_596) - (* (- 50) x_601) - (* (- 60) x_606) - (* (- 70) x_611) - (* (- 80) x_616) - (* (- 40) x_621) - (* (- 50) x_626) - (* (- 60) x_631) - (* (- 70) x_636) - (* (- 80) x_641) - (* (- 90) x_646) - (* (- 100) x_651) - (* (- 110) x_656) - (* (- 40) x_661) - (* (- 50) x_666) - (* (- 60) x_671) - (* (- 70) x_676) - (* (- 40) x_681) - (* (- 50) x_686) - (* (- 60) x_691) - (* (- 70) x_696) - (* (- 80) x_701) - (* (- 90) x_706) - (* (- 100) x_711) - (* (- 110) x_716) - (* (- 120) x_721) - (* (- 40) x_726) - (* (- 50) x_731) - (* (- 60) x_736) - (* (- 70) x_741) - (* (- 80) x_746) - (* (- 90) x_751) - (* (- 100) x_756) - (* (- 110) x_761) - (* (- 40) x_766) - (* (- 50) x_771) - (* (- 40) x_776) - (* (- 50) x_781) - (* (- 40) x_786) - (* (- 50) x_791) - (* (- 60) x_796) - (* (- 70) x_801) - (* (- 80) x_806) - (* (- 90) x_811) - (* (- 100) x_816) - (* (- 40) x_821) - (* (- 50) x_826) - (* (- 60) x_831) - (* (- 70) x_836) - (* (- 80) x_841) - (* (- 90) x_846) - (* (- 100) x_851) - (* (- 110) x_856) - (* (- 40) x_861) - (* (- 50) x_866) - (* (- 60) x_871) - (* (- 70) x_876) - (* (- 80) x_881) - (* (- 90) x_886) - (* (- 40) x_891) - (* (- 50) x_896) - (* (- 60) x_901) - (* (- 70) x_906) - (* (- 80) x_911) - (* (- 90) x_916) - (* (- 100) x_921) - (* (- 52) x_926) - (* (- 52) x_931) - (* (- 65) x_936) - (* (- 52) x_941) - (* (- 52) x_946) - (* (- 65) x_951) - (* (- 52) x_956) - (* (- 65) x_961) - (* (- 52) x_966) - (* (- 65) x_971) - (* (- 78) x_976) - (* (- 91) x_981) - (* (- 104) x_986) - (* (- 117) x_991) - (* (- 130) x_996) - (* (- 40) x_1)))) -(assert (<= 0 - (+ (* 26500 x_1403) - (* (- 50) x_7) - (* (- 40) x_12) - (* (- 50) x_17) - (* (- 60) x_22) - (* (- 40) x_27) - (* (- 40) x_32) - (* (- 50) x_37) - (* (- 40) x_42) - (* (- 40) x_47) - (* (- 40) x_52) - (* (- 50) x_57) - (* (- 40) x_62) - (* (- 40) x_67) - (* (- 50) x_72) - (* (- 60) x_77) - (* (- 70) x_82) - (* (- 80) x_87) - (* (- 90) x_92) - (* (- 100) x_97) - (* (- 40) x_102) - (* (- 50) x_107) - (* (- 60) x_112) - (* (- 70) x_117) - (* (- 40) x_122) - (* (- 50) x_127) - (* (- 60) x_132) - (* (- 70) x_137) - (* (- 80) x_142) - (* (- 90) x_147) - (* (- 100) x_152) - (* (- 110) x_157) - (* (- 120) x_162) - (* (- 40) x_167) - (* (- 50) x_172) - (* (- 60) x_177) - (* (- 70) x_182) - (* (- 40) x_187) - (* (- 50) x_192) - (* (- 60) x_197) - (* (- 40) x_202) - (* (- 50) x_207) - (* (- 40) x_212) - (* (- 50) x_217) - (* (- 60) x_222) - (* (- 70) x_227) - (* (- 80) x_232) - (* (- 90) x_237) - (* (- 100) x_242) - (* (- 110) x_247) - (* (- 40) x_252) - (* (- 50) x_257) - (* (- 60) x_262) - (* (- 70) x_267) - (* (- 80) x_272) - (* (- 90) x_277) - (* (- 100) x_282) - (* (- 40) x_287) - (* (- 50) x_292) - (* (- 60) x_297) - (* (- 70) x_302) - (* (- 80) x_307) - (* (- 90) x_312) - (* (- 100) x_317) - (* (- 110) x_322) - (* (- 40) x_327) - (* (- 50) x_332) - (* (- 60) x_337) - (* (- 70) x_342) - (* (- 80) x_347) - (* (- 90) x_352) - (* (- 100) x_357) - (* (- 40) x_362) - (* (- 50) x_367) - (* (- 60) x_372) - (* (- 70) x_377) - (* (- 80) x_382) - (* (- 90) x_387) - (* (- 100) x_392) - (* (- 40) x_397) - (* (- 50) x_402) - (* (- 60) x_407) - (* (- 40) x_412) - (* (- 50) x_417) - (* (- 60) x_422) - (* (- 70) x_427) - (* (- 80) x_432) - (* (- 90) x_437) - (* (- 100) x_442) - (* (- 110) x_447) - (* (- 120) x_452) - (* (- 130) x_457) - (* (- 40) x_462) - (* (- 50) x_467) - (* (- 60) x_472) - (* (- 70) x_477) - (* (- 80) x_482) - (* (- 90) x_487) - (* (- 40) x_492) - (* (- 40) x_497) - (* (- 50) x_502) - (* (- 60) x_507) - (* (- 70) x_512) - (* (- 80) x_517) - (* (- 90) x_522) - (* (- 40) x_527) - (* (- 50) x_532) - (* (- 60) x_537) - (* (- 40) x_542) - (* (- 50) x_547) - (* (- 60) x_552) - (* (- 70) x_557) - (* (- 40) x_562) - (* (- 50) x_567) - (* (- 60) x_572) - (* (- 70) x_577) - (* (- 80) x_582) - (* (- 90) x_587) - (* (- 40) x_592) - (* (- 40) x_597) - (* (- 50) x_602) - (* (- 60) x_607) - (* (- 70) x_612) - (* (- 80) x_617) - (* (- 40) x_622) - (* (- 50) x_627) - (* (- 60) x_632) - (* (- 70) x_637) - (* (- 80) x_642) - (* (- 90) x_647) - (* (- 100) x_652) - (* (- 110) x_657) - (* (- 40) x_662) - (* (- 50) x_667) - (* (- 60) x_672) - (* (- 70) x_677) - (* (- 40) x_682) - (* (- 50) x_687) - (* (- 60) x_692) - (* (- 70) x_697) - (* (- 80) x_702) - (* (- 90) x_707) - (* (- 100) x_712) - (* (- 110) x_717) - (* (- 120) x_722) - (* (- 40) x_727) - (* (- 50) x_732) - (* (- 60) x_737) - (* (- 70) x_742) - (* (- 80) x_747) - (* (- 90) x_752) - (* (- 100) x_757) - (* (- 110) x_762) - (* (- 40) x_767) - (* (- 50) x_772) - (* (- 40) x_777) - (* (- 50) x_782) - (* (- 40) x_787) - (* (- 50) x_792) - (* (- 60) x_797) - (* (- 70) x_802) - (* (- 80) x_807) - (* (- 90) x_812) - (* (- 100) x_817) - (* (- 40) x_822) - (* (- 50) x_827) - (* (- 60) x_832) - (* (- 70) x_837) - (* (- 80) x_842) - (* (- 90) x_847) - (* (- 100) x_852) - (* (- 110) x_857) - (* (- 40) x_862) - (* (- 50) x_867) - (* (- 60) x_872) - (* (- 70) x_877) - (* (- 80) x_882) - (* (- 90) x_887) - (* (- 40) x_892) - (* (- 50) x_897) - (* (- 60) x_902) - (* (- 70) x_907) - (* (- 80) x_912) - (* (- 90) x_917) - (* (- 100) x_922) - (* (- 52) x_927) - (* (- 52) x_932) - (* (- 65) x_937) - (* (- 52) x_942) - (* (- 52) x_947) - (* (- 65) x_952) - (* (- 52) x_957) - (* (- 65) x_962) - (* (- 52) x_967) - (* (- 65) x_972) - (* (- 78) x_977) - (* (- 91) x_982) - (* (- 104) x_987) - (* (- 117) x_992) - (* (- 130) x_997) - (* (- 40) x_2)))) -(assert (<= 0 - (+ (* 4500 x_1604) - (* (- 50) x_8) - (* (- 40) x_13) - (* (- 50) x_18) - (* (- 60) x_23) - (* (- 40) x_28) - (* (- 40) x_33) - (* (- 50) x_38) - (* (- 40) x_43) - (* (- 40) x_48) - (* (- 40) x_53) - (* (- 50) x_58) - (* (- 40) x_63) - (* (- 40) x_68) - (* (- 50) x_73) - (* (- 60) x_78) - (* (- 70) x_83) - (* (- 80) x_88) - (* (- 90) x_93) - (* (- 100) x_98) - (* (- 40) x_103) - (* (- 50) x_108) - (* (- 60) x_113) - (* (- 70) x_118) - (* (- 40) x_123) - (* (- 50) x_128) - (* (- 60) x_133) - (* (- 70) x_138) - (* (- 80) x_143) - (* (- 90) x_148) - (* (- 100) x_153) - (* (- 110) x_158) - (* (- 120) x_163) - (* (- 40) x_168) - (* (- 50) x_173) - (* (- 60) x_178) - (* (- 70) x_183) - (* (- 40) x_188) - (* (- 50) x_193) - (* (- 60) x_198) - (* (- 40) x_203) - (* (- 50) x_208) - (* (- 40) x_213) - (* (- 50) x_218) - (* (- 60) x_223) - (* (- 70) x_228) - (* (- 80) x_233) - (* (- 90) x_238) - (* (- 100) x_243) - (* (- 110) x_248) - (* (- 40) x_253) - (* (- 50) x_258) - (* (- 60) x_263) - (* (- 70) x_268) - (* (- 80) x_273) - (* (- 90) x_278) - (* (- 100) x_283) - (* (- 40) x_288) - (* (- 50) x_293) - (* (- 60) x_298) - (* (- 70) x_303) - (* (- 80) x_308) - (* (- 90) x_313) - (* (- 100) x_318) - (* (- 110) x_323) - (* (- 40) x_328) - (* (- 50) x_333) - (* (- 60) x_338) - (* (- 70) x_343) - (* (- 80) x_348) - (* (- 90) x_353) - (* (- 100) x_358) - (* (- 40) x_363) - (* (- 50) x_368) - (* (- 60) x_373) - (* (- 70) x_378) - (* (- 80) x_383) - (* (- 90) x_388) - (* (- 100) x_393) - (* (- 40) x_398) - (* (- 50) x_403) - (* (- 60) x_408) - (* (- 40) x_413) - (* (- 50) x_418) - (* (- 60) x_423) - (* (- 70) x_428) - (* (- 80) x_433) - (* (- 90) x_438) - (* (- 100) x_443) - (* (- 110) x_448) - (* (- 120) x_453) - (* (- 130) x_458) - (* (- 40) x_463) - (* (- 50) x_468) - (* (- 60) x_473) - (* (- 70) x_478) - (* (- 80) x_483) - (* (- 90) x_488) - (* (- 40) x_493) - (* (- 40) x_498) - (* (- 50) x_503) - (* (- 60) x_508) - (* (- 70) x_513) - (* (- 80) x_518) - (* (- 90) x_523) - (* (- 40) x_528) - (* (- 50) x_533) - (* (- 60) x_538) - (* (- 40) x_543) - (* (- 50) x_548) - (* (- 60) x_553) - (* (- 70) x_558) - (* (- 40) x_563) - (* (- 50) x_568) - (* (- 60) x_573) - (* (- 70) x_578) - (* (- 80) x_583) - (* (- 90) x_588) - (* (- 40) x_593) - (* (- 40) x_598) - (* (- 50) x_603) - (* (- 60) x_608) - (* (- 70) x_613) - (* (- 80) x_618) - (* (- 40) x_623) - (* (- 50) x_628) - (* (- 60) x_633) - (* (- 70) x_638) - (* (- 80) x_643) - (* (- 90) x_648) - (* (- 100) x_653) - (* (- 110) x_658) - (* (- 40) x_663) - (* (- 50) x_668) - (* (- 60) x_673) - (* (- 70) x_678) - (* (- 40) x_683) - (* (- 50) x_688) - (* (- 60) x_693) - (* (- 70) x_698) - (* (- 80) x_703) - (* (- 90) x_708) - (* (- 100) x_713) - (* (- 110) x_718) - (* (- 120) x_723) - (* (- 40) x_728) - (* (- 50) x_733) - (* (- 60) x_738) - (* (- 70) x_743) - (* (- 80) x_748) - (* (- 90) x_753) - (* (- 100) x_758) - (* (- 110) x_763) - (* (- 40) x_768) - (* (- 50) x_773) - (* (- 40) x_778) - (* (- 50) x_783) - (* (- 40) x_788) - (* (- 50) x_793) - (* (- 60) x_798) - (* (- 70) x_803) - (* (- 80) x_808) - (* (- 90) x_813) - (* (- 100) x_818) - (* (- 40) x_823) - (* (- 50) x_828) - (* (- 60) x_833) - (* (- 70) x_838) - (* (- 80) x_843) - (* (- 90) x_848) - (* (- 100) x_853) - (* (- 110) x_858) - (* (- 40) x_863) - (* (- 50) x_868) - (* (- 60) x_873) - (* (- 70) x_878) - (* (- 80) x_883) - (* (- 90) x_888) - (* (- 40) x_893) - (* (- 50) x_898) - (* (- 60) x_903) - (* (- 70) x_908) - (* (- 80) x_913) - (* (- 90) x_918) - (* (- 100) x_923) - (* (- 52) x_928) - (* (- 52) x_933) - (* (- 65) x_938) - (* (- 52) x_943) - (* (- 52) x_948) - (* (- 65) x_953) - (* (- 52) x_958) - (* (- 65) x_963) - (* (- 52) x_968) - (* (- 65) x_973) - (* (- 78) x_978) - (* (- 91) x_983) - (* (- 104) x_988) - (* (- 117) x_993) - (* (- 130) x_998) - (* (- 40) x_3)))) -(assert (<= 0 - (+ (* 3850 x_1001) - (* (- 30) x_9) - (* (- 24) x_14) - (* (- 30) x_19) - (* (- 36) x_24) - (* (- 24) x_29) - (* (- 24) x_34) - (* (- 30) x_39) - (* (- 24) x_44) - (* (- 24) x_49) - (* (- 24) x_54) - (* (- 30) x_59) - (* (- 24) x_64) - (* (- 24) x_69) - (* (- 30) x_74) - (* (- 36) x_79) - (* (- 42) x_84) - (* (- 48) x_89) - (* (- 54) x_94) - (* (- 60) x_99) - (* (- 24) x_104) - (* (- 30) x_109) - (* (- 36) x_114) - (* (- 42) x_119) - (* (- 24) x_124) - (* (- 30) x_129) - (* (- 36) x_134) - (* (- 42) x_139) - (* (- 48) x_144) - (* (- 54) x_149) - (* (- 60) x_154) - (* (- 66) x_159) - (* (- 72) x_164) - (* (- 24) x_169) - (* (- 30) x_174) - (* (- 36) x_179) - (* (- 42) x_184) - (* (- 24) x_189) - (* (- 30) x_194) - (* (- 36) x_199) - (* (- 24) x_204) - (* (- 30) x_209) - (* (- 24) x_214) - (* (- 30) x_219) - (* (- 36) x_224) - (* (- 42) x_229) - (* (- 48) x_234) - (* (- 54) x_239) - (* (- 60) x_244) - (* (- 66) x_249) - (* (- 24) x_254) - (* (- 30) x_259) - (* (- 36) x_264) - (* (- 42) x_269) - (* (- 48) x_274) - (* (- 54) x_279) - (* (- 60) x_284) - (* (- 24) x_289) - (* (- 30) x_294) - (* (- 36) x_299) - (* (- 42) x_304) - (* (- 48) x_309) - (* (- 54) x_314) - (* (- 60) x_319) - (* (- 66) x_324) - (* (- 24) x_329) - (* (- 30) x_334) - (* (- 36) x_339) - (* (- 42) x_344) - (* (- 48) x_349) - (* (- 54) x_354) - (* (- 60) x_359) - (* (- 24) x_364) - (* (- 30) x_369) - (* (- 36) x_374) - (* (- 42) x_379) - (* (- 48) x_384) - (* (- 54) x_389) - (* (- 60) x_394) - (* (- 24) x_399) - (* (- 30) x_404) - (* (- 36) x_409) - (* (- 24) x_414) - (* (- 30) x_419) - (* (- 36) x_424) - (* (- 42) x_429) - (* (- 48) x_434) - (* (- 54) x_439) - (* (- 60) x_444) - (* (- 66) x_449) - (* (- 72) x_454) - (* (- 78) x_459) - (* (- 24) x_464) - (* (- 30) x_469) - (* (- 36) x_474) - (* (- 42) x_479) - (* (- 48) x_484) - (* (- 54) x_489) - (* (- 24) x_494) - (* (- 24) x_499) - (* (- 30) x_504) - (* (- 36) x_509) - (* (- 42) x_514) - (* (- 48) x_519) - (* (- 54) x_524) - (* (- 24) x_529) - (* (- 30) x_534) - (* (- 36) x_539) - (* (- 24) x_544) - (* (- 30) x_549) - (* (- 36) x_554) - (* (- 42) x_559) - (* (- 24) x_564) - (* (- 30) x_569) - (* (- 36) x_574) - (* (- 42) x_579) - (* (- 48) x_584) - (* (- 54) x_589) - (* (- 24) x_594) - (* (- 24) x_599) - (* (- 30) x_604) - (* (- 36) x_609) - (* (- 42) x_614) - (* (- 48) x_619) - (* (- 24) x_624) - (* (- 30) x_629) - (* (- 36) x_634) - (* (- 42) x_639) - (* (- 48) x_644) - (* (- 54) x_649) - (* (- 60) x_654) - (* (- 66) x_659) - (* (- 24) x_664) - (* (- 30) x_669) - (* (- 36) x_674) - (* (- 42) x_679) - (* (- 24) x_684) - (* (- 30) x_689) - (* (- 36) x_694) - (* (- 42) x_699) - (* (- 48) x_704) - (* (- 54) x_709) - (* (- 60) x_714) - (* (- 66) x_719) - (* (- 72) x_724) - (* (- 24) x_729) - (* (- 30) x_734) - (* (- 36) x_739) - (* (- 42) x_744) - (* (- 48) x_749) - (* (- 54) x_754) - (* (- 60) x_759) - (* (- 66) x_764) - (* (- 24) x_769) - (* (- 30) x_774) - (* (- 24) x_779) - (* (- 30) x_784) - (* (- 24) x_789) - (* (- 30) x_794) - (* (- 36) x_799) - (* (- 42) x_804) - (* (- 48) x_809) - (* (- 54) x_814) - (* (- 60) x_819) - (* (- 24) x_824) - (* (- 30) x_829) - (* (- 36) x_834) - (* (- 42) x_839) - (* (- 48) x_844) - (* (- 54) x_849) - (* (- 60) x_854) - (* (- 66) x_859) - (* (- 24) x_864) - (* (- 30) x_869) - (* (- 36) x_874) - (* (- 42) x_879) - (* (- 48) x_884) - (* (- 54) x_889) - (* (- 24) x_894) - (* (- 30) x_899) - (* (- 36) x_904) - (* (- 42) x_909) - (* (- 48) x_914) - (* (- 54) x_919) - (* (- 60) x_924) - (* (- 36) x_929) - (* (- 36) x_934) - (* (- 45) x_939) - (* (- 36) x_944) - (* (- 36) x_949) - (* (- 45) x_954) - (* (- 36) x_959) - (* (- 45) x_964) - (* (- 36) x_969) - (* (- 45) x_974) - (* (- 54) x_979) - (* (- 63) x_984) - (* (- 72) x_989) - (* (- 81) x_994) - (* (- 90) x_999) - (* (- 24) x_4)))) -(assert (<= 0 - (+ (* 3000 x_1202) - (* (- 30) x_6) - (* (- 24) x_11) - (* (- 30) x_16) - (* (- 36) x_21) - (* (- 24) x_26) - (* (- 24) x_31) - (* (- 30) x_36) - (* (- 24) x_41) - (* (- 24) x_46) - (* (- 24) x_51) - (* (- 30) x_56) - (* (- 24) x_61) - (* (- 24) x_66) - (* (- 30) x_71) - (* (- 36) x_76) - (* (- 42) x_81) - (* (- 48) x_86) - (* (- 54) x_91) - (* (- 60) x_96) - (* (- 24) x_101) - (* (- 30) x_106) - (* (- 36) x_111) - (* (- 42) x_116) - (* (- 24) x_121) - (* (- 30) x_126) - (* (- 36) x_131) - (* (- 42) x_136) - (* (- 48) x_141) - (* (- 54) x_146) - (* (- 60) x_151) - (* (- 66) x_156) - (* (- 72) x_161) - (* (- 24) x_166) - (* (- 30) x_171) - (* (- 36) x_176) - (* (- 42) x_181) - (* (- 24) x_186) - (* (- 30) x_191) - (* (- 36) x_196) - (* (- 24) x_201) - (* (- 30) x_206) - (* (- 24) x_211) - (* (- 30) x_216) - (* (- 36) x_221) - (* (- 42) x_226) - (* (- 48) x_231) - (* (- 54) x_236) - (* (- 60) x_241) - (* (- 66) x_246) - (* (- 24) x_251) - (* (- 30) x_256) - (* (- 36) x_261) - (* (- 42) x_266) - (* (- 48) x_271) - (* (- 54) x_276) - (* (- 60) x_281) - (* (- 24) x_286) - (* (- 30) x_291) - (* (- 36) x_296) - (* (- 42) x_301) - (* (- 48) x_306) - (* (- 54) x_311) - (* (- 60) x_316) - (* (- 66) x_321) - (* (- 24) x_326) - (* (- 30) x_331) - (* (- 36) x_336) - (* (- 42) x_341) - (* (- 48) x_346) - (* (- 54) x_351) - (* (- 60) x_356) - (* (- 24) x_361) - (* (- 30) x_366) - (* (- 36) x_371) - (* (- 42) x_376) - (* (- 48) x_381) - (* (- 54) x_386) - (* (- 60) x_391) - (* (- 24) x_396) - (* (- 30) x_401) - (* (- 36) x_406) - (* (- 24) x_411) - (* (- 30) x_416) - (* (- 36) x_421) - (* (- 42) x_426) - (* (- 48) x_431) - (* (- 54) x_436) - (* (- 60) x_441) - (* (- 66) x_446) - (* (- 72) x_451) - (* (- 78) x_456) - (* (- 24) x_461) - (* (- 30) x_466) - (* (- 36) x_471) - (* (- 42) x_476) - (* (- 48) x_481) - (* (- 54) x_486) - (* (- 24) x_491) - (* (- 24) x_496) - (* (- 30) x_501) - (* (- 36) x_506) - (* (- 42) x_511) - (* (- 48) x_516) - (* (- 54) x_521) - (* (- 24) x_526) - (* (- 30) x_531) - (* (- 36) x_536) - (* (- 24) x_541) - (* (- 30) x_546) - (* (- 36) x_551) - (* (- 42) x_556) - (* (- 24) x_561) - (* (- 30) x_566) - (* (- 36) x_571) - (* (- 42) x_576) - (* (- 48) x_581) - (* (- 54) x_586) - (* (- 24) x_591) - (* (- 24) x_596) - (* (- 30) x_601) - (* (- 36) x_606) - (* (- 42) x_611) - (* (- 48) x_616) - (* (- 24) x_621) - (* (- 30) x_626) - (* (- 36) x_631) - (* (- 42) x_636) - (* (- 48) x_641) - (* (- 54) x_646) - (* (- 60) x_651) - (* (- 66) x_656) - (* (- 24) x_661) - (* (- 30) x_666) - (* (- 36) x_671) - (* (- 42) x_676) - (* (- 24) x_681) - (* (- 30) x_686) - (* (- 36) x_691) - (* (- 42) x_696) - (* (- 48) x_701) - (* (- 54) x_706) - (* (- 60) x_711) - (* (- 66) x_716) - (* (- 72) x_721) - (* (- 24) x_726) - (* (- 30) x_731) - (* (- 36) x_736) - (* (- 42) x_741) - (* (- 48) x_746) - (* (- 54) x_751) - (* (- 60) x_756) - (* (- 66) x_761) - (* (- 24) x_766) - (* (- 30) x_771) - (* (- 24) x_776) - (* (- 30) x_781) - (* (- 24) x_786) - (* (- 30) x_791) - (* (- 36) x_796) - (* (- 42) x_801) - (* (- 48) x_806) - (* (- 54) x_811) - (* (- 60) x_816) - (* (- 24) x_821) - (* (- 30) x_826) - (* (- 36) x_831) - (* (- 42) x_836) - (* (- 48) x_841) - (* (- 54) x_846) - (* (- 60) x_851) - (* (- 66) x_856) - (* (- 24) x_861) - (* (- 30) x_866) - (* (- 36) x_871) - (* (- 42) x_876) - (* (- 48) x_881) - (* (- 54) x_886) - (* (- 24) x_891) - (* (- 30) x_896) - (* (- 36) x_901) - (* (- 42) x_906) - (* (- 48) x_911) - (* (- 54) x_916) - (* (- 60) x_921) - (* (- 36) x_926) - (* (- 36) x_931) - (* (- 45) x_936) - (* (- 36) x_941) - (* (- 36) x_946) - (* (- 45) x_951) - (* (- 36) x_956) - (* (- 45) x_961) - (* (- 36) x_966) - (* (- 45) x_971) - (* (- 54) x_976) - (* (- 63) x_981) - (* (- 72) x_986) - (* (- 81) x_991) - (* (- 90) x_996) - (* (- 24) x_1)))) -(assert (<= 0 - (+ (* 7700 x_1403) - (* (- 30) x_7) - (* (- 24) x_12) - (* (- 30) x_17) - (* (- 36) x_22) - (* (- 24) x_27) - (* (- 24) x_32) - (* (- 30) x_37) - (* (- 24) x_42) - (* (- 24) x_47) - (* (- 24) x_52) - (* (- 30) x_57) - (* (- 24) x_62) - (* (- 24) x_67) - (* (- 30) x_72) - (* (- 36) x_77) - (* (- 42) x_82) - (* (- 48) x_87) - (* (- 54) x_92) - (* (- 60) x_97) - (* (- 24) x_102) - (* (- 30) x_107) - (* (- 36) x_112) - (* (- 42) x_117) - (* (- 24) x_122) - (* (- 30) x_127) - (* (- 36) x_132) - (* (- 42) x_137) - (* (- 48) x_142) - (* (- 54) x_147) - (* (- 60) x_152) - (* (- 66) x_157) - (* (- 72) x_162) - (* (- 24) x_167) - (* (- 30) x_172) - (* (- 36) x_177) - (* (- 42) x_182) - (* (- 24) x_187) - (* (- 30) x_192) - (* (- 36) x_197) - (* (- 24) x_202) - (* (- 30) x_207) - (* (- 24) x_212) - (* (- 30) x_217) - (* (- 36) x_222) - (* (- 42) x_227) - (* (- 48) x_232) - (* (- 54) x_237) - (* (- 60) x_242) - (* (- 66) x_247) - (* (- 24) x_252) - (* (- 30) x_257) - (* (- 36) x_262) - (* (- 42) x_267) - (* (- 48) x_272) - (* (- 54) x_277) - (* (- 60) x_282) - (* (- 24) x_287) - (* (- 30) x_292) - (* (- 36) x_297) - (* (- 42) x_302) - (* (- 48) x_307) - (* (- 54) x_312) - (* (- 60) x_317) - (* (- 66) x_322) - (* (- 24) x_327) - (* (- 30) x_332) - (* (- 36) x_337) - (* (- 42) x_342) - (* (- 48) x_347) - (* (- 54) x_352) - (* (- 60) x_357) - (* (- 24) x_362) - (* (- 30) x_367) - (* (- 36) x_372) - (* (- 42) x_377) - (* (- 48) x_382) - (* (- 54) x_387) - (* (- 60) x_392) - (* (- 24) x_397) - (* (- 30) x_402) - (* (- 36) x_407) - (* (- 24) x_412) - (* (- 30) x_417) - (* (- 36) x_422) - (* (- 42) x_427) - (* (- 48) x_432) - (* (- 54) x_437) - (* (- 60) x_442) - (* (- 66) x_447) - (* (- 72) x_452) - (* (- 78) x_457) - (* (- 24) x_462) - (* (- 30) x_467) - (* (- 36) x_472) - (* (- 42) x_477) - (* (- 48) x_482) - (* (- 54) x_487) - (* (- 24) x_492) - (* (- 24) x_497) - (* (- 30) x_502) - (* (- 36) x_507) - (* (- 42) x_512) - (* (- 48) x_517) - (* (- 54) x_522) - (* (- 24) x_527) - (* (- 30) x_532) - (* (- 36) x_537) - (* (- 24) x_542) - (* (- 30) x_547) - (* (- 36) x_552) - (* (- 42) x_557) - (* (- 24) x_562) - (* (- 30) x_567) - (* (- 36) x_572) - (* (- 42) x_577) - (* (- 48) x_582) - (* (- 54) x_587) - (* (- 24) x_592) - (* (- 24) x_597) - (* (- 30) x_602) - (* (- 36) x_607) - (* (- 42) x_612) - (* (- 48) x_617) - (* (- 24) x_622) - (* (- 30) x_627) - (* (- 36) x_632) - (* (- 42) x_637) - (* (- 48) x_642) - (* (- 54) x_647) - (* (- 60) x_652) - (* (- 66) x_657) - (* (- 24) x_662) - (* (- 30) x_667) - (* (- 36) x_672) - (* (- 42) x_677) - (* (- 24) x_682) - (* (- 30) x_687) - (* (- 36) x_692) - (* (- 42) x_697) - (* (- 48) x_702) - (* (- 54) x_707) - (* (- 60) x_712) - (* (- 66) x_717) - (* (- 72) x_722) - (* (- 24) x_727) - (* (- 30) x_732) - (* (- 36) x_737) - (* (- 42) x_742) - (* (- 48) x_747) - (* (- 54) x_752) - (* (- 60) x_757) - (* (- 66) x_762) - (* (- 24) x_767) - (* (- 30) x_772) - (* (- 24) x_777) - (* (- 30) x_782) - (* (- 24) x_787) - (* (- 30) x_792) - (* (- 36) x_797) - (* (- 42) x_802) - (* (- 48) x_807) - (* (- 54) x_812) - (* (- 60) x_817) - (* (- 24) x_822) - (* (- 30) x_827) - (* (- 36) x_832) - (* (- 42) x_837) - (* (- 48) x_842) - (* (- 54) x_847) - (* (- 60) x_852) - (* (- 66) x_857) - (* (- 24) x_862) - (* (- 30) x_867) - (* (- 36) x_872) - (* (- 42) x_877) - (* (- 48) x_882) - (* (- 54) x_887) - (* (- 24) x_892) - (* (- 30) x_897) - (* (- 36) x_902) - (* (- 42) x_907) - (* (- 48) x_912) - (* (- 54) x_917) - (* (- 60) x_922) - (* (- 36) x_927) - (* (- 36) x_932) - (* (- 45) x_937) - (* (- 36) x_942) - (* (- 36) x_947) - (* (- 45) x_952) - (* (- 36) x_957) - (* (- 45) x_962) - (* (- 36) x_967) - (* (- 45) x_972) - (* (- 54) x_977) - (* (- 63) x_982) - (* (- 72) x_987) - (* (- 81) x_992) - (* (- 90) x_997) - (* (- 24) x_2)))) -(assert (<= 0 - (+ (* 3960 x_1604) - (* (- 30) x_8) - (* (- 24) x_13) - (* (- 30) x_18) - (* (- 36) x_23) - (* (- 24) x_28) - (* (- 24) x_33) - (* (- 30) x_38) - (* (- 24) x_43) - (* (- 24) x_48) - (* (- 24) x_53) - (* (- 30) x_58) - (* (- 24) x_63) - (* (- 24) x_68) - (* (- 30) x_73) - (* (- 36) x_78) - (* (- 42) x_83) - (* (- 48) x_88) - (* (- 54) x_93) - (* (- 60) x_98) - (* (- 24) x_103) - (* (- 30) x_108) - (* (- 36) x_113) - (* (- 42) x_118) - (* (- 24) x_123) - (* (- 30) x_128) - (* (- 36) x_133) - (* (- 42) x_138) - (* (- 48) x_143) - (* (- 54) x_148) - (* (- 60) x_153) - (* (- 66) x_158) - (* (- 72) x_163) - (* (- 24) x_168) - (* (- 30) x_173) - (* (- 36) x_178) - (* (- 42) x_183) - (* (- 24) x_188) - (* (- 30) x_193) - (* (- 36) x_198) - (* (- 24) x_203) - (* (- 30) x_208) - (* (- 24) x_213) - (* (- 30) x_218) - (* (- 36) x_223) - (* (- 42) x_228) - (* (- 48) x_233) - (* (- 54) x_238) - (* (- 60) x_243) - (* (- 66) x_248) - (* (- 24) x_253) - (* (- 30) x_258) - (* (- 36) x_263) - (* (- 42) x_268) - (* (- 48) x_273) - (* (- 54) x_278) - (* (- 60) x_283) - (* (- 24) x_288) - (* (- 30) x_293) - (* (- 36) x_298) - (* (- 42) x_303) - (* (- 48) x_308) - (* (- 54) x_313) - (* (- 60) x_318) - (* (- 66) x_323) - (* (- 24) x_328) - (* (- 30) x_333) - (* (- 36) x_338) - (* (- 42) x_343) - (* (- 48) x_348) - (* (- 54) x_353) - (* (- 60) x_358) - (* (- 24) x_363) - (* (- 30) x_368) - (* (- 36) x_373) - (* (- 42) x_378) - (* (- 48) x_383) - (* (- 54) x_388) - (* (- 60) x_393) - (* (- 24) x_398) - (* (- 30) x_403) - (* (- 36) x_408) - (* (- 24) x_413) - (* (- 30) x_418) - (* (- 36) x_423) - (* (- 42) x_428) - (* (- 48) x_433) - (* (- 54) x_438) - (* (- 60) x_443) - (* (- 66) x_448) - (* (- 72) x_453) - (* (- 78) x_458) - (* (- 24) x_463) - (* (- 30) x_468) - (* (- 36) x_473) - (* (- 42) x_478) - (* (- 48) x_483) - (* (- 54) x_488) - (* (- 24) x_493) - (* (- 24) x_498) - (* (- 30) x_503) - (* (- 36) x_508) - (* (- 42) x_513) - (* (- 48) x_518) - (* (- 54) x_523) - (* (- 24) x_528) - (* (- 30) x_533) - (* (- 36) x_538) - (* (- 24) x_543) - (* (- 30) x_548) - (* (- 36) x_553) - (* (- 42) x_558) - (* (- 24) x_563) - (* (- 30) x_568) - (* (- 36) x_573) - (* (- 42) x_578) - (* (- 48) x_583) - (* (- 54) x_588) - (* (- 24) x_593) - (* (- 24) x_598) - (* (- 30) x_603) - (* (- 36) x_608) - (* (- 42) x_613) - (* (- 48) x_618) - (* (- 24) x_623) - (* (- 30) x_628) - (* (- 36) x_633) - (* (- 42) x_638) - (* (- 48) x_643) - (* (- 54) x_648) - (* (- 60) x_653) - (* (- 66) x_658) - (* (- 24) x_663) - (* (- 30) x_668) - (* (- 36) x_673) - (* (- 42) x_678) - (* (- 24) x_683) - (* (- 30) x_688) - (* (- 36) x_693) - (* (- 42) x_698) - (* (- 48) x_703) - (* (- 54) x_708) - (* (- 60) x_713) - (* (- 66) x_718) - (* (- 72) x_723) - (* (- 24) x_728) - (* (- 30) x_733) - (* (- 36) x_738) - (* (- 42) x_743) - (* (- 48) x_748) - (* (- 54) x_753) - (* (- 60) x_758) - (* (- 66) x_763) - (* (- 24) x_768) - (* (- 30) x_773) - (* (- 24) x_778) - (* (- 30) x_783) - (* (- 24) x_788) - (* (- 30) x_793) - (* (- 36) x_798) - (* (- 42) x_803) - (* (- 48) x_808) - (* (- 54) x_813) - (* (- 60) x_818) - (* (- 24) x_823) - (* (- 30) x_828) - (* (- 36) x_833) - (* (- 42) x_838) - (* (- 48) x_843) - (* (- 54) x_848) - (* (- 60) x_853) - (* (- 66) x_858) - (* (- 24) x_863) - (* (- 30) x_868) - (* (- 36) x_873) - (* (- 42) x_878) - (* (- 48) x_883) - (* (- 54) x_888) - (* (- 24) x_893) - (* (- 30) x_898) - (* (- 36) x_903) - (* (- 42) x_908) - (* (- 48) x_913) - (* (- 54) x_918) - (* (- 60) x_923) - (* (- 36) x_928) - (* (- 36) x_933) - (* (- 45) x_938) - (* (- 36) x_943) - (* (- 36) x_948) - (* (- 45) x_953) - (* (- 36) x_958) - (* (- 45) x_963) - (* (- 36) x_968) - (* (- 45) x_973) - (* (- 54) x_978) - (* (- 63) x_983) - (* (- 72) x_988) - (* (- 81) x_993) - (* (- 90) x_998) - (* (- 24) x_3)))) - -(assert (= x_1202 1)) -(assert (= x_1403 1)) -(assert (= x_1604 0)) -(assert (= x_1001 0)) - -;(minimize (+ x_1202 x_1403 x_1604 x_1001)) -(minimize (+ (* 2 x_1) - (* 3 x_2) - (* 4 x_3) - x_9 - (* 2 x_6) - (* 3 x_7) - (* 4 x_8) - x_14 - (* 2 x_11) - (* 3 x_12) - (* 4 x_13) - x_19 - (* 2 x_16) - (* 3 x_17) - (* 4 x_18) - x_24 - (* 2 x_21) - (* 3 x_22) - (* 4 x_23) - x_29 - (* 2 x_26) - (* 3 x_27) - (* 4 x_28) - x_34 - (* 2 x_31) - (* 3 x_32) - (* 4 x_33) - x_39 - (* 2 x_36) - (* 3 x_37) - (* 4 x_38) - x_44 - (* 2 x_41) - (* 3 x_42) - (* 4 x_43) - x_49 - (* 2 x_46) - (* 3 x_47) - (* 4 x_48) - x_54 - (* 2 x_51) - (* 3 x_52) - (* 4 x_53) - x_59 - (* 2 x_56) - (* 3 x_57) - (* 4 x_58) - x_64 - (* 2 x_61) - (* 3 x_62) - (* 4 x_63) - x_69 - (* 2 x_66) - (* 3 x_67) - (* 4 x_68) - x_74 - (* 2 x_71) - (* 3 x_72) - (* 4 x_73) - x_79 - (* 2 x_76) - (* 3 x_77) - (* 4 x_78) - x_84 - (* 2 x_81) - (* 3 x_82) - (* 4 x_83) - x_89 - (* 2 x_86) - (* 3 x_87) - (* 4 x_88) - x_94 - (* 2 x_91) - (* 3 x_92) - (* 4 x_93) - x_99 - (* 2 x_96) - (* 3 x_97) - (* 4 x_98) - x_104 - (* 2 x_101) - (* 3 x_102) - (* 4 x_103) - x_109 - (* 2 x_106) - (* 3 x_107) - (* 4 x_108) - x_114 - (* 2 x_111) - (* 3 x_112) - (* 4 x_113) - x_119 - (* 2 x_116) - (* 3 x_117) - (* 4 x_118) - x_124 - (* 2 x_121) - (* 3 x_122) - (* 4 x_123) - x_129 - (* 2 x_126) - (* 3 x_127) - (* 4 x_128) - x_134 - (* 2 x_131) - (* 3 x_132) - (* 4 x_133) - x_139 - (* 2 x_136) - (* 3 x_137) - (* 4 x_138) - x_144 - (* 2 x_141) - (* 3 x_142) - (* 4 x_143) - x_149 - (* 2 x_146) - (* 3 x_147) - (* 4 x_148) - x_154 - (* 2 x_151) - (* 3 x_152) - (* 4 x_153) - x_159 - (* 2 x_156) - (* 3 x_157) - (* 4 x_158) - x_164 - (* 2 x_161) - (* 3 x_162) - (* 4 x_163) - x_169 - (* 2 x_166) - (* 3 x_167) - (* 4 x_168) - x_174 - (* 2 x_171) - (* 3 x_172) - (* 4 x_173) - x_179 - (* 2 x_176) - (* 3 x_177) - (* 4 x_178) - x_184 - (* 2 x_181) - (* 3 x_182) - (* 4 x_183) - x_189 - (* 2 x_186) - (* 3 x_187) - (* 4 x_188) - x_194 - (* 2 x_191) - (* 3 x_192) - (* 4 x_193) - x_199 - (* 2 x_196) - (* 3 x_197) - (* 4 x_198) - x_204 - (* 2 x_201) - (* 3 x_202) - (* 4 x_203) - x_209 - (* 2 x_206) - (* 3 x_207) - (* 4 x_208) - x_214 - (* 2 x_211) - (* 3 x_212) - (* 4 x_213) - x_219 - (* 2 x_216) - (* 3 x_217) - (* 4 x_218) - x_224 - (* 2 x_221) - (* 3 x_222) - (* 4 x_223) - x_229 - (* 2 x_226) - (* 3 x_227) - (* 4 x_228) - x_234 - (* 2 x_231) - (* 3 x_232) - (* 4 x_233) - x_239 - (* 2 x_236) - (* 3 x_237) - (* 4 x_238) - x_244 - (* 2 x_241) - (* 3 x_242) - (* 4 x_243) - x_249 - (* 2 x_246) - (* 3 x_247) - (* 4 x_248) - x_254 - (* 2 x_251) - (* 3 x_252) - (* 4 x_253) - x_259 - (* 2 x_256) - (* 3 x_257) - (* 4 x_258) - x_264 - (* 2 x_261) - (* 3 x_262) - (* 4 x_263) - x_269 - (* 2 x_266) - (* 3 x_267) - (* 4 x_268) - x_274 - (* 2 x_271) - (* 3 x_272) - (* 4 x_273) - x_279 - (* 2 x_276) - (* 3 x_277) - (* 4 x_278) - x_284 - (* 2 x_281) - (* 3 x_282) - (* 4 x_283) - x_289 - (* 2 x_286) - (* 3 x_287) - (* 4 x_288) - x_294 - (* 2 x_291) - (* 3 x_292) - (* 4 x_293) - x_299 - (* 2 x_296) - (* 3 x_297) - (* 4 x_298) - x_304 - (* 2 x_301) - (* 3 x_302) - (* 4 x_303) - x_309 - (* 2 x_306) - (* 3 x_307) - (* 4 x_308) - x_314 - (* 2 x_311) - (* 3 x_312) - (* 4 x_313) - x_319 - (* 2 x_316) - (* 3 x_317) - (* 4 x_318) - x_324 - (* 2 x_321) - (* 3 x_322) - (* 4 x_323) - x_329 - (* 2 x_326) - (* 3 x_327) - (* 4 x_328) - x_334 - (* 2 x_331) - (* 3 x_332) - (* 4 x_333) - x_339 - (* 2 x_336) - (* 3 x_337) - (* 4 x_338) - x_344 - (* 2 x_341) - (* 3 x_342) - (* 4 x_343) - x_349 - (* 2 x_346) - (* 3 x_347) - (* 4 x_348) - x_354 - (* 2 x_351) - (* 3 x_352) - (* 4 x_353) - x_359 - (* 2 x_356) - (* 3 x_357) - (* 4 x_358) - x_364 - (* 2 x_361) - (* 3 x_362) - (* 4 x_363) - x_369 - (* 2 x_366) - (* 3 x_367) - (* 4 x_368) - x_374 - (* 2 x_371) - (* 3 x_372) - (* 4 x_373) - x_379 - (* 2 x_376) - (* 3 x_377) - (* 4 x_378) - x_384 - (* 2 x_381) - (* 3 x_382) - (* 4 x_383) - x_389 - (* 2 x_386) - (* 3 x_387) - (* 4 x_388) - x_394 - (* 2 x_391) - (* 3 x_392) - (* 4 x_393) - x_399 - (* 2 x_396) - (* 3 x_397) - (* 4 x_398) - x_404 - (* 2 x_401) - (* 3 x_402) - (* 4 x_403) - x_409 - (* 2 x_406) - (* 3 x_407) - (* 4 x_408) - x_414 - (* 2 x_411) - (* 3 x_412) - (* 4 x_413) - x_419 - (* 2 x_416) - (* 3 x_417) - (* 4 x_418) - x_424 - (* 2 x_421) - (* 3 x_422) - (* 4 x_423) - x_429 - (* 2 x_426) - (* 3 x_427) - (* 4 x_428) - x_434 - (* 2 x_431) - (* 3 x_432) - (* 4 x_433) - x_439 - (* 2 x_436) - (* 3 x_437) - (* 4 x_438) - x_444 - (* 2 x_441) - (* 3 x_442) - (* 4 x_443) - x_449 - (* 2 x_446) - (* 3 x_447) - (* 4 x_448) - x_454 - (* 2 x_451) - (* 3 x_452) - (* 4 x_453) - x_459 - (* 2 x_456) - (* 3 x_457) - (* 4 x_458) - x_464 - (* 2 x_461) - (* 3 x_462) - (* 4 x_463) - x_469 - (* 2 x_466) - (* 3 x_467) - (* 4 x_468) - x_474 - (* 2 x_471) - (* 3 x_472) - (* 4 x_473) - x_479 - (* 2 x_476) - (* 3 x_477) - (* 4 x_478) - x_484 - (* 2 x_481) - (* 3 x_482) - (* 4 x_483) - x_489 - (* 2 x_486) - (* 3 x_487) - (* 4 x_488) - x_494 - (* 2 x_491) - (* 3 x_492) - (* 4 x_493) - x_499 - (* 2 x_496) - (* 3 x_497) - (* 4 x_498) - x_504 - (* 2 x_501) - (* 3 x_502) - (* 4 x_503) - x_509 - (* 2 x_506) - (* 3 x_507) - (* 4 x_508) - x_514 - (* 2 x_511) - (* 3 x_512) - (* 4 x_513) - x_519 - (* 2 x_516) - (* 3 x_517) - (* 4 x_518) - x_524 - (* 2 x_521) - (* 3 x_522) - (* 4 x_523) - x_529 - (* 2 x_526) - (* 3 x_527) - (* 4 x_528) - x_534 - (* 2 x_531) - (* 3 x_532) - (* 4 x_533) - x_539 - (* 2 x_536) - (* 3 x_537) - (* 4 x_538) - x_544 - (* 2 x_541) - (* 3 x_542) - (* 4 x_543) - x_549 - (* 2 x_546) - (* 3 x_547) - (* 4 x_548) - x_554 - (* 2 x_551) - (* 3 x_552) - (* 4 x_553) - x_559 - (* 2 x_556) - (* 3 x_557) - (* 4 x_558) - x_564 - (* 2 x_561) - (* 3 x_562) - (* 4 x_563) - x_569 - (* 2 x_566) - (* 3 x_567) - (* 4 x_568) - x_574 - (* 2 x_571) - (* 3 x_572) - (* 4 x_573) - x_579 - (* 2 x_576) - (* 3 x_577) - (* 4 x_578) - x_584 - (* 2 x_581) - (* 3 x_582) - (* 4 x_583) - x_589 - (* 2 x_586) - (* 3 x_587) - (* 4 x_588) - x_594 - (* 2 x_591) - (* 3 x_592) - (* 4 x_593) - x_599 - (* 2 x_596) - (* 3 x_597) - (* 4 x_598) - x_604 - (* 2 x_601) - (* 3 x_602) - (* 4 x_603) - x_609 - (* 2 x_606) - (* 3 x_607) - (* 4 x_608) - x_614 - (* 2 x_611) - (* 3 x_612) - (* 4 x_613) - x_619 - (* 2 x_616) - (* 3 x_617) - (* 4 x_618) - x_624 - (* 2 x_621) - (* 3 x_622) - (* 4 x_623) - x_629 - (* 2 x_626) - (* 3 x_627) - (* 4 x_628) - x_634 - (* 2 x_631) - (* 3 x_632) - (* 4 x_633) - x_639 - (* 2 x_636) - (* 3 x_637) - (* 4 x_638) - x_644 - (* 2 x_641) - (* 3 x_642) - (* 4 x_643) - x_649 - (* 2 x_646) - (* 3 x_647) - (* 4 x_648) - x_654 - (* 2 x_651) - (* 3 x_652) - (* 4 x_653) - x_659 - (* 2 x_656) - (* 3 x_657) - (* 4 x_658) - x_664 - (* 2 x_661) - (* 3 x_662) - (* 4 x_663) - x_669 - (* 2 x_666) - (* 3 x_667) - (* 4 x_668) - x_674 - (* 2 x_671) - (* 3 x_672) - (* 4 x_673) - x_679 - (* 2 x_676) - (* 3 x_677) - (* 4 x_678) - x_684 - (* 2 x_681) - (* 3 x_682) - (* 4 x_683) - x_689 - (* 2 x_686) - (* 3 x_687) - (* 4 x_688) - x_694 - (* 2 x_691) - (* 3 x_692) - (* 4 x_693) - x_699 - (* 2 x_696) - (* 3 x_697) - (* 4 x_698) - x_704 - (* 2 x_701) - (* 3 x_702) - (* 4 x_703) - x_709 - (* 2 x_706) - (* 3 x_707) - (* 4 x_708) - x_714 - (* 2 x_711) - (* 3 x_712) - (* 4 x_713) - x_719 - (* 2 x_716) - (* 3 x_717) - (* 4 x_718) - x_724 - (* 2 x_721) - (* 3 x_722) - (* 4 x_723) - x_729 - (* 2 x_726) - (* 3 x_727) - (* 4 x_728) - x_734 - (* 2 x_731) - (* 3 x_732) - (* 4 x_733) - x_739 - (* 2 x_736) - (* 3 x_737) - (* 4 x_738) - x_744 - (* 2 x_741) - (* 3 x_742) - (* 4 x_743) - x_749 - (* 2 x_746) - (* 3 x_747) - (* 4 x_748) - x_754 - (* 2 x_751) - (* 3 x_752) - (* 4 x_753) - x_759 - (* 2 x_756) - (* 3 x_757) - (* 4 x_758) - x_764 - (* 2 x_761) - (* 3 x_762) - (* 4 x_763) - x_769 - (* 2 x_766) - (* 3 x_767) - (* 4 x_768) - x_774 - (* 2 x_771) - (* 3 x_772) - (* 4 x_773) - x_779 - (* 2 x_776) - (* 3 x_777) - (* 4 x_778) - x_784 - (* 2 x_781) - (* 3 x_782) - (* 4 x_783) - x_789 - (* 2 x_786) - (* 3 x_787) - (* 4 x_788) - x_794 - (* 2 x_791) - (* 3 x_792) - (* 4 x_793) - x_799 - (* 2 x_796) - (* 3 x_797) - (* 4 x_798) - x_804 - (* 2 x_801) - (* 3 x_802) - (* 4 x_803) - x_809 - (* 2 x_806) - (* 3 x_807) - (* 4 x_808) - x_814 - (* 2 x_811) - (* 3 x_812) - (* 4 x_813) - x_819 - (* 2 x_816) - (* 3 x_817) - (* 4 x_818) - x_824 - (* 2 x_821) - (* 3 x_822) - (* 4 x_823) - x_829 - (* 2 x_826) - (* 3 x_827) - (* 4 x_828) - x_834 - (* 2 x_831) - (* 3 x_832) - (* 4 x_833) - x_839 - (* 2 x_836) - (* 3 x_837) - (* 4 x_838) - x_844 - (* 2 x_841) - (* 3 x_842) - (* 4 x_843) - x_849 - (* 2 x_846) - (* 3 x_847) - (* 4 x_848) - x_854 - (* 2 x_851) - (* 3 x_852) - (* 4 x_853) - x_859 - (* 2 x_856) - (* 3 x_857) - (* 4 x_858) - x_864 - (* 2 x_861) - (* 3 x_862) - (* 4 x_863) - x_869 - (* 2 x_866) - (* 3 x_867) - (* 4 x_868) - x_874 - (* 2 x_871) - (* 3 x_872) - (* 4 x_873) - x_879 - (* 2 x_876) - (* 3 x_877) - (* 4 x_878) - x_884 - (* 2 x_881) - (* 3 x_882) - (* 4 x_883) - x_889 - (* 2 x_886) - (* 3 x_887) - (* 4 x_888) - x_894 - (* 2 x_891) - (* 3 x_892) - (* 4 x_893) - x_899 - (* 2 x_896) - (* 3 x_897) - (* 4 x_898) - x_904 - (* 2 x_901) - (* 3 x_902) - (* 4 x_903) - x_909 - (* 2 x_906) - (* 3 x_907) - (* 4 x_908) - x_914 - (* 2 x_911) - (* 3 x_912) - (* 4 x_913) - x_919 - (* 2 x_916) - (* 3 x_917) - (* 4 x_918) - x_924 - (* 2 x_921) - (* 3 x_922) - (* 4 x_923) - x_929 - (* 2 x_926) - (* 3 x_927) - (* 4 x_928) - x_934 - (* 2 x_931) - (* 3 x_932) - (* 4 x_933) - x_939 - (* 2 x_936) - (* 3 x_937) - (* 4 x_938) - x_944 - (* 2 x_941) - (* 3 x_942) - (* 4 x_943) - x_949 - (* 2 x_946) - (* 3 x_947) - (* 4 x_948) - x_954 - (* 2 x_951) - (* 3 x_952) - (* 4 x_953) - x_959 - (* 2 x_956) - (* 3 x_957) - (* 4 x_958) - x_964 - (* 2 x_961) - (* 3 x_962) - (* 4 x_963) - x_969 - (* 2 x_966) - (* 3 x_967) - (* 4 x_968) - x_974 - (* 2 x_971) - (* 3 x_972) - (* 4 x_973) - x_979 - (* 2 x_976) - (* 3 x_977) - (* 4 x_978) - x_984 - (* 2 x_981) - (* 3 x_982) - (* 4 x_983) - x_989 - (* 2 x_986) - (* 3 x_987) - (* 4 x_988) - x_994 - (* 2 x_991) - (* 3 x_992) - (* 4 x_993) - x_999 - (* 2 x_996) - (* 3 x_997) - (* 4 x_998) - x_4 - (* 100 x_1202) - (* 100 x_1403) - (* 100 x_1604) - (* 100 x_1001))) -(optimize :print_statistics true - :wmaxsat_engine wmax - :maxsat_engine weighted_maxsat)