}
}
+Type Parser::mkFlatFunctionType(std::vector<Type>& sorts,
+ Type range,
+ std::vector<Expr>& flattenVars)
+{
+ if (range.isFunction())
+ {
+ std::vector<Type> domainTypes =
+ (static_cast<FunctionType>(range)).getArgTypes();
+ for (unsigned i = 0, size = domainTypes.size(); i < size; i++)
+ {
+ sorts.push_back(domainTypes[i]);
+ // the introduced variable is internal (not parsable)
+ std::stringstream ss;
+ ss << "__flatten_var_" << i;
+ Expr v = d_exprManager->mkBoundVar(ss.str(), domainTypes[i]);
+ flattenVars.push_back(v);
+ }
+ range = static_cast<FunctionType>(range).getRangeType();
+ }
+ if (sorts.empty())
+ {
+ return range;
+ }
+ return d_exprManager->mkFunctionType(sorts, range);
+}
+
+Type Parser::mkFlatFunctionType(std::vector<Type>& sorts, Type range)
+{
+ if (sorts.empty())
+ {
+ // no difference
+ return range;
+ }
+ while (range.isFunction())
+ {
+ std::vector<Type> domainTypes =
+ static_cast<FunctionType>(range).getArgTypes();
+ sorts.insert(sorts.end(), domainTypes.begin(), domainTypes.end());
+ range = static_cast<FunctionType>(range).getRangeType();
+ }
+ return d_exprManager->mkFunctionType(sorts, range);
+}
+
+Expr Parser::mkHoApply(Expr expr, std::vector<Expr>& args, unsigned startIndex)
+{
+ for (unsigned i = startIndex; i < args.size(); i++)
+ {
+ expr = d_exprManager->mkExpr(HO_APPLY, expr, args[i]);
+ }
+ return expr;
+}
+
bool Parser::isDeclared(const std::string& name, SymbolType type) {
switch (type) {
case SYM_VARIABLE:
std::vector<DatatypeType>
mkMutualDatatypeTypes(std::vector<Datatype>& datatypes, bool doOverload=false);
+ /** make flat function type
+ *
+ * Returns the "flat" function type corresponding to the function taking
+ * argument types "sorts" and range type "range". A flat function type is
+ * one whose range is not a function. Notice that if sorts is empty and range
+ * is not a function, then this function returns range itself.
+ *
+ * If range is a function type, we add its function argument sorts to sorts
+ * and consider its function range as the new range. For each sort S added
+ * to sorts in this process, we add a new bound variable of sort S to
+ * flattenVars.
+ *
+ * For example:
+ * mkFlattenFunctionType( { Int, (-> Real Real) }, (-> Int Bool), {} ):
+ * - returns the the function type (-> Int (-> Real Real) Int Bool)
+ * - updates sorts to { Int, (-> Real Real), Int },
+ * - updates flattenVars to { x }, where x is bound variable of type Int.
+ *
+ * Notice that this method performs only one level of flattening, for example,
+ * mkFlattenFunctionType({ Int, (-> Real Real) }, (-> Int (-> Int Bool)), {}):
+ * - returns the the function type (-> Int (-> Real Real) Int (-> Int Bool))
+ * - updates sorts to { Int, (-> Real Real), Int },
+ * - updates flattenVars to { x }, where x is bound variable of type Int.
+ *
+ * This method is required so that we do not return functions
+ * that have function return type (these give an unhandled exception
+ * in the ExprManager). For examples of the equivalence between function
+ * definitions in the proposed higher-order extension of the smt2 language,
+ * see page 3 of http://matryoshka.gforge.inria.fr/pubs/PxTP2017.pdf.
+ *
+ * The argument flattenVars is needed in the case of defined functions
+ * with function return type. These have implicit arguments, for instance:
+ * (define-fun Q ((x Int)) (-> Int Int) (lambda y (P x)))
+ * is equivalent to the command:
+ * (define-fun Q ((x Int) (z Int)) Int (@ (lambda y (P x)) z))
+ * where @ is (higher-order) application. In this example, z is added to
+ * flattenVars.
+ */
+ Type mkFlatFunctionType(std::vector<Type>& sorts,
+ Type range,
+ std::vector<Expr>& flattenVars);
+
+ /** make flat function type
+ *
+ * Same as above, but does not take argument flattenVars.
+ * This is used when the arguments of the function are not important (for
+ * instance, if we are only using this type in a declare-fun).
+ */
+ Type mkFlatFunctionType(std::vector<Type>& sorts, Type range);
+
+ /** make higher-order apply
+ *
+ * This returns the left-associative curried application of (function) expr to
+ * the arguments in args, starting at index startIndex.
+ *
+ * For example, mkHoApply( f, { a, b }, 0 ) returns
+ * (HO_APPLY (HO_APPLY f a) b)
+ *
+ * If args is non-empty, the expected type of expr is (-> T0 ... Tn T), where
+ * args[i-startIndex].getType() = Ti
+ * for each i where startIndex <= i < args.size(). If expr is not of this
+ * type, the expression returned by this method will not be well typed.
+ */
+ Expr mkHoApply(Expr expr, std::vector<Expr>& args, unsigned startIndex = 0);
+
/**
* Add an operator to the current legal set.
*
std::vector<Expr> terms;
std::vector<Type> sorts;
std::vector<std::pair<std::string, Type> > sortedVarNames;
+ std::vector<Expr> flattenVars;
}
: /* set the logic */
SET_LOGIC_TOK symbol[name,CHECK_NONE,SYM_SORT]
LPAREN_TOK sortList[sorts] RPAREN_TOK
sortSymbol[t,CHECK_DECLARED]
{ Debug("parser") << "declare fun: '" << name << "'" << std::endl;
- if( sorts.size() > 0 ) {
- if(!PARSER_STATE->isTheoryEnabled(Smt2::THEORY_UF)) {
- PARSER_STATE->parseErrorLogic("Functions (of non-zero arity) cannot "
- "be declared in logic ");
- }
- t = EXPR_MANAGER->mkFunctionType(sorts, t);
+ if( !sorts.empty() ) {
+ t = PARSER_STATE->mkFlatFunctionType(sorts, t);
+ }
+ if(t.isFunction() && !PARSER_STATE->isTheoryEnabled(Smt2::THEORY_UF)) {
+ PARSER_STATE->parseErrorLogic("Functions (of non-zero arity) cannot "
+ "be declared in logic ");
}
// we allow overloading for function declarations
Expr func = PARSER_STATE->mkVar(name, t, ExprManager::VAR_FLAG_NONE, true);
{ /* add variables to parser state before parsing term */
Debug("parser") << "define fun: '" << name << "'" << std::endl;
if( sortedVarNames.size() > 0 ) {
- std::vector<CVC4::Type> sorts;
sorts.reserve(sortedVarNames.size());
for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator i =
sortedVarNames.begin(), iend = sortedVarNames.end();
++i) {
sorts.push_back((*i).second);
}
- t = EXPR_MANAGER->mkFunctionType(sorts, t);
+ t = PARSER_STATE->mkFlatFunctionType(sorts, t, flattenVars);
}
PARSER_STATE->pushScope(true);
for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator i =
}
}
term[expr, expr2]
- { PARSER_STATE->popScope();
+ {
+ if( !flattenVars.empty() ){
+ // if this function has any implicit variables flattenVars,
+ // we apply the body of the definition to the flatten vars
+ expr = PARSER_STATE->mkHoApply(expr, flattenVars);
+ terms.insert(terms.end(), flattenVars.begin(), flattenVars.end());
+ }
+ PARSER_STATE->popScope();
// declare the name down here (while parsing term, signature
// must not be extended with the name itself; no recursion
// permitted)
if( range.isNull() ){
PARSER_STATE->parseError("Must supply return type for synth-fun.");
}
+ if( range.isFunction() ){
+ PARSER_STATE->parseError("Cannot use synth-fun with function return type.");
+ }
seq.reset(new CommandSequence());
std::vector<Type> var_sorts;
for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator i =
std::vector<std::pair<std::string, Type> > sortedVarNames;
SExpr sexpr;
Type t;
+ Expr func;
Expr func_app;
std::vector<Expr> bvs;
std::vector< std::vector<std::pair<std::string, Type> > > sortedVarNamesList;
+ std::vector<std::vector<Expr>> flattenVarsList;
std::vector<Expr> funcs;
std::vector<Expr> func_defs;
Expr aexpr;
std::unique_ptr<CVC4::CommandSequence> seq;
+ std::vector<Type> sorts;
+ std::vector<Expr> flattenVars;
}
/* meta-info */
: META_INFO_TOK metaInfoInternal[cmd]
{ PARSER_STATE->checkUserSymbol(fname); }
LPAREN_TOK sortedVarList[sortedVarNames] RPAREN_TOK
sortSymbol[t,CHECK_DECLARED]
- { if( sortedVarNames.size() > 0 ) {
- std::vector<CVC4::Type> sorts;
- sorts.reserve(sortedVarNames.size());
- for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator i =
- sortedVarNames.begin(), iend = sortedVarNames.end(); i != iend;
- ++i) {
- sorts.push_back((*i).second);
- }
- t = EXPR_MANAGER->mkFunctionType(sorts, t);
- }
- // allow overloading
- Expr func = PARSER_STATE->mkVar(fname, t, ExprManager::VAR_FLAG_NONE, true);
+ {
+ func = PARSER_STATE->mkDefineFunRec(fname, sortedVarNames, t, flattenVars);
seq->addCommand(new DeclareFunctionCommand(fname, func, t));
- if( sortedVarNames.empty() ){
- func_app = func;
- }else{
- std::vector< Expr > f_app;
- f_app.push_back( func );
- PARSER_STATE->pushScope(true);
- for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator i =
- sortedVarNames.begin(), iend = sortedVarNames.end(); i != iend;
- ++i) {
- Expr v = PARSER_STATE->mkBoundVar((*i).first, (*i).second);
- bvs.push_back( v );
- f_app.push_back( v );
- }
- func_app = MK_EXPR( kind::APPLY_UF, f_app );
- }
+ PARSER_STATE->pushDefineFunRecScope(sortedVarNames, func, flattenVars, func_app, bvs, true );
}
term[expr, expr2]
{ PARSER_STATE->popScope();
+ if( !flattenVars.empty() ){
+ expr = PARSER_STATE->mkHoApply( expr, flattenVars );
+ }
Expr as = MK_EXPR( kind::EQUAL, func_app, expr);
if( !bvs.empty() ){
std::string attr_name("fun-def");
{ PARSER_STATE->checkUserSymbol(fname); }
LPAREN_TOK sortedVarList[sortedVarNames] RPAREN_TOK
sortSymbol[t,CHECK_DECLARED]
- { sortedVarNamesList.push_back( sortedVarNames );
- if( sortedVarNamesList[0].size() > 0 ) {
- if( !sortedVarNames.empty() ){
- std::vector<CVC4::Type> sorts;
- for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator
- i = sortedVarNames.begin(), iend = sortedVarNames.end();
- i != iend; ++i) {
- sorts.push_back((*i).second);
- }
- t = EXPR_MANAGER->mkFunctionType(sorts, t);
- }
- }
- sortedVarNames.clear();
- // allow overloading
- Expr func = PARSER_STATE->mkVar(fname, t, ExprManager::VAR_FLAG_NONE, true);
+ {
+ flattenVars.clear();
+ func = PARSER_STATE->mkDefineFunRec( fname, sortedVarNames, t, flattenVars );
seq->addCommand(new DeclareFunctionCommand(fname, func, t));
funcs.push_back( func );
+
+ // add to lists (need to remember for when parsing the bodies)
+ sortedVarNamesList.push_back( sortedVarNames );
+ flattenVarsList.push_back( flattenVars );
+
+ // set up parsing the next variable list block
+ sortedVarNames.clear();
+ flattenVars.clear();
}
RPAREN_TOK
)+
PARSER_STATE->parseError("Must define at least one function in "
"define-funs-rec");
}
- PARSER_STATE->pushScope(true);
bvs.clear();
- if( sortedVarNamesList[0].empty() ){
- func_app = funcs[0];
- }else{
- std::vector< Expr > f_app;
- f_app.push_back( funcs[0] );
- for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator
- i = sortedVarNamesList[0].begin(),
- iend = sortedVarNamesList[0].end(); i != iend; ++i) {
- Expr v = PARSER_STATE->mkBoundVar((*i).first, (*i).second);
- bvs.push_back( v );
- f_app.push_back( v );
- }
- func_app = MK_EXPR( kind::APPLY_UF, f_app );
- }
+ PARSER_STATE->pushDefineFunRecScope( sortedVarNamesList[0], funcs[0],
+ flattenVarsList[0], func_app, bvs, true);
}
(
term[expr,expr2]
{
+ unsigned j = func_defs.size();
+ if( !flattenVarsList[j].empty() ){
+ expr = PARSER_STATE->mkHoApply( expr, flattenVarsList[j] );
+ }
func_defs.push_back( expr );
+ j++;
Expr as = MK_EXPR( kind::EQUAL, func_app, expr );
if( !bvs.empty() ){
std::string attr_name("fun-def");
//set up the next scope
PARSER_STATE->popScope();
if( func_defs.size()<funcs.size() ){
- PARSER_STATE->pushScope(true);
bvs.clear();
- unsigned j = func_defs.size();
- if( sortedVarNamesList[j].empty() ){
- func_app = funcs[j];
- }else{
- std::vector< Expr > f_app;
- f_app.push_back( funcs[j] );
- for(std::vector<std::pair<std::string, CVC4::Type> >::const_iterator
- i = sortedVarNamesList[j].begin(),
- iend = sortedVarNamesList[j].end(); i != iend; ++i) {
- Expr v = PARSER_STATE->mkBoundVar((*i).first, (*i).second);
- bvs.push_back( v );
- f_app.push_back( v );
- }
- func_app = MK_EXPR( kind::APPLY_UF, f_app );
- }
+ PARSER_STATE->pushDefineFunRecScope( sortedVarNamesList[j], funcs[j],
+ flattenVarsList[j], func_app, bvs, true);
}
}
)+
PARSER_STATE->parseErrorLogic("Functions (of non-zero arity) "
"cannot be declared in logic ");
}
- t = EXPR_MANAGER->mkFunctionType(sorts);
+ // must flatten
+ Type range = sorts.back();
+ sorts.pop_back();
+ t = PARSER_STATE->mkFlatFunctionType(sorts, range);
} else {
t = sorts[0];
}
if(isBuiltinOperator) {
PARSER_STATE->checkOperator(kind, args.size());
}
- expr = MK_EXPR(kind, args);
+ // may be partially applied function, in this case we should use HO_APPLY
+ if( args.size()>=2 && args[0].getType().isFunction() &&
+ (args.size()-1)<((FunctionType)args[0].getType()).getArity() ){
+ Debug("parser") << "Partial application of " << args[0];
+ Debug("parser") << " : #argTypes = " << ((FunctionType)args[0].getType()).getArity();
+ Debug("parser") << ", #args = " << args.size()-1 << std::endl;
+ // must curry the application
+ expr = args[0];
+ expr = PARSER_STATE->mkHoApply( expr, args, 1 );
+ }else{
+ expr = MK_EXPR(kind, args);
+ }
}
| LPAREN_TOK
expr2 = f2;
}
}
+ | /* lambda */
+ LPAREN_TOK HO_LAMBDA_TOK
+ LPAREN_TOK sortedVarList[sortedVarNames] RPAREN_TOK
+ {
+ PARSER_STATE->pushScope(true);
+ for(const std::pair<std::string, CVC4::Type>& svn : sortedVarNames){
+ args.push_back(PARSER_STATE->mkBoundVar(svn.first, svn.second));
+ }
+ Expr bvl = MK_EXPR(kind::BOUND_VAR_LIST, args);
+ args.clear();
+ args.push_back(bvl);
+ }
+ term[f, f2] RPAREN_TOK
+ {
+ args.push_back( f );
+ PARSER_STATE->popScope();
+ expr = MK_EXPR( CVC4::kind::LAMBDA, args );
+ }
/* constants */
| INTEGER_LITERAL
{ expr = MK_CONST( AntlrInput::tokenToInteger($INTEGER_LITERAL) ); }
}
}
) RPAREN_TOK
+ | LPAREN_TOK HO_ARROW_TOK sortList[args] RPAREN_TOK
+ {
+ if(args.size()<2) {
+ PARSER_STATE->parseError("Arrow types must have at least 2 arguments");
+ }
+ //flatten the type
+ Type rangeType = args.back();
+ args.pop_back();
+ t = PARSER_STATE->mkFlatFunctionType( args, rangeType );
+ }
;
/**
FP_RTN_FULL_TOK : { PARSER_STATE->isTheoryEnabled(Smt2::THEORY_FP) }? 'roundTowardNegative';
FP_RTZ_FULL_TOK : { PARSER_STATE->isTheoryEnabled(Smt2::THEORY_FP) }? 'roundTowardZero';
+HO_ARROW_TOK : { PARSER_STATE->getLogic().isHigherOrder() }? '->';
+HO_LAMBDA_TOK : { PARSER_STATE->getLogic().isHigherOrder() }? 'lambda';
+
/**
* A sequence of printable ASCII characters (except backslash) that starts
* and ends with | and does not otherwise contain |.
}
}
+Expr Smt2::mkDefineFunRec(
+ const std::string& fname,
+ const std::vector<std::pair<std::string, Type> >& sortedVarNames,
+ Type t,
+ std::vector<Expr>& flattenVars)
+{
+ std::vector<Type> sorts;
+ for (const std::pair<std::string, CVC4::Type>& svn : sortedVarNames)
+ {
+ sorts.push_back(svn.second);
+ }
+
+ // make the flattened function type, add bound variables
+ // to flattenVars if the defined function was given a function return type.
+ Type ft = mkFlatFunctionType(sorts, t, flattenVars);
+
+ // allow overloading
+ return mkVar(fname, ft, ExprManager::VAR_FLAG_NONE, true);
+}
+
+void Smt2::pushDefineFunRecScope(
+ const std::vector<std::pair<std::string, Type> >& sortedVarNames,
+ Expr func,
+ const std::vector<Expr>& flattenVars,
+ Expr& func_app,
+ std::vector<Expr>& bvs,
+ bool bindingLevel)
+{
+ pushScope(bindingLevel);
+
+ std::vector<Expr> f_app;
+ f_app.push_back(func);
+ // bound variables are those that are explicitly named in the preamble
+ // of the define-fun(s)-rec command, we define them here
+ for (const std::pair<std::string, CVC4::Type>& svn : sortedVarNames)
+ {
+ Expr v = mkBoundVar(svn.first, svn.second);
+ bvs.push_back(v);
+ f_app.push_back(v);
+ }
+
+ bvs.insert(bvs.end(), flattenVars.begin(), flattenVars.end());
+
+ // make the function application
+ if (bvs.empty())
+ {
+ // it has no arguments
+ func_app = func;
+ }
+ else
+ {
+ func_app = getExprManager()->mkExpr(kind::APPLY_UF, f_app);
+ }
+}
+
void Smt2::reset() {
d_logicSet = false;
d_logic = LogicInfo();
*/
virtual Expr getExpressionForNameAndType(const std::string& name, Type t);
+ /** Make function defined by a define-fun(s)-rec command.
+ *
+ * fname : the name of the function.
+ * sortedVarNames : the list of variable arguments for the function.
+ * t : the range type of the function we are defining.
+ *
+ * This function will create a bind a new function term to name fname.
+ * The type of this function is
+ * Parser::mkFlatFunctionType(sorts,t,flattenVars),
+ * where sorts are the types in the second components of sortedVarNames.
+ * As descibed in Parser::mkFlatFunctionType, new bound variables may be
+ * added to flattenVars in this function if the function is given a function
+ * range type.
+ */
+ Expr mkDefineFunRec(
+ const std::string& fname,
+ const std::vector<std::pair<std::string, Type> >& sortedVarNames,
+ Type t,
+ std::vector<Expr>& flattenVars);
+
+ /** Push scope for define-fun-rec
+ *
+ * This calls Parser::pushScope(bindingLevel) and sets up
+ * initial information for reading a body of a function definition
+ * in the define-fun-rec and define-funs-rec command.
+ * The input parameters func/flattenVars are the result
+ * of a call to mkDefineRec above.
+ *
+ * func : the function whose body we are defining.
+ * sortedVarNames : the list of variable arguments for the function.
+ * flattenVars : the implicit variables introduced when defining func.
+ *
+ * This function:
+ * (1) Calls Parser::pushScope(bindingLevel).
+ * (2) Computes the bound variable list for the quantified formula
+ * that defined this definition and stores it in bvs.
+ * (3) Sets func_app to the APPLY_UF with func applied to bvs.
+ */
+ void pushDefineFunRecScope(
+ const std::vector<std::pair<std::string, Type> >& sortedVarNames,
+ Expr func,
+ const std::vector<Expr>& flattenVars,
+ Expr& func_app,
+ std::vector<Expr>& bvs,
+ bool bindingLevel = false);
+
void reset();
void resetAssertions();
regress/regress0/decision \
regress/regress0/expect \
regress/regress0/fmf \
+ regress/regress0/ho \
regress/regress0/lemmas \
regress/regress0/nl \
regress/regress0/parser \
-SUBDIRS = . expect arith precedence uf uflra uflia bv arrays aufbv auflia datatypes quantifiers rewriterules lemmas push-pop preprocess tptp unconstrained decision fmf strings sets rels parser sygus sep nl
+SUBDIRS = . expect arith precedence uf uflra uflia bv arrays aufbv auflia datatypes quantifiers rewriterules lemmas push-pop preprocess tptp unconstrained decision fmf strings sets rels parser sygus sep nl ho
DIST_SUBDIRS = $(SUBDIRS)
# don't override a BINARY imported from a personal.mk
issue1063-overloading-dt-sel.smt2 \
issue1063-overloading-dt-fun.smt2 \
non-fatal-errors.smt2 \
- sqrt2-sort-inf-unk.smt2
+ sqrt2-sort-inf-unk.smt2 \
+ rec-fun-const-parse-bug.smt2
# Regression tests for PL inputs
--- /dev/null
+# don't override a BINARY imported from a personal.mk
+@mk_if@eq ($(BINARY),)
+@mk_empty@BINARY = cvc4
+end@mk_if@
+
+LOG_COMPILER = @srcdir@/../../run_regression
+AM_LOG_FLAGS = $(RUN_REGRESSION_ARGS) @abs_top_builddir@/src/main/$(BINARY)$(EXEEXT)
+
+if AUTOMAKE_1_11
+# old-style (pre-automake 1.12) test harness
+TESTS_ENVIRONMENT = \
+ $(LOG_COMPILER) \
+ $(AM_LOG_FLAGS) $(LOG_FLAGS)
+endif
+
+MAKEFLAGS = -k
+
+# These are run for all build profiles.
+# If a test shouldn't be run in e.g. competition mode,
+# put it below in "TESTS +="
+TESTS = \
+ cong.smt2 \
+ ext-ho-nested-lambda-model.smt2 \
+ declare-fun-variants.smt2 \
+ ext-ho.smt2 \
+ trans.smt2 \
+ ext-finite-unsat.smt2 \
+ ext-sat.smt2 \
+ cong-full-apply.smt2 \
+ def-fun-flatten.smt2 \
+ lambda-equality-non-canon.smt2 \
+ ite-apply-eq.smt2 \
+ apply-collapse-unsat.smt2 \
+ apply-collapse-sat.smt2 \
+ ho-exponential-model.smt2 \
+ ext-sat-partial-eval.smt2 \
+ ho-std-fmf.smt2 \
+ fta0409.smt2 \
+ auth0068.smt2 \
+ modulo-func-equality.smt2
+
+EXTRA_DIST = $(TESTS)
+
+# need PR 1204 :
+
+# hoa0102.smt2
+# ho-matching-enum.smt2
+# ho-matching-enum-2.smt2
+# ho-matching-nested-app.smt2
+# simple-matching.smt2
+# simple-matching-partial.smt2
+
+
+#if CVC4_BUILD_PROFILE_COMPETITION
+#else
+#TESTS += \
+# error.cvc
+#endif
+#
+# and make sure to distribute it
+#EXTRA_DIST += \
+# error.cvc
+
+
+# synonyms for "check" in this directory
+.PHONY: regress regress0 test
+regress regress0 test: check
+
+# do nothing in this subdir
+.PHONY: regress1 regress2 regress3 regress4
+regress1 regress2 regress3 regress4:
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic UF)
+(set-info :status sat)
+(declare-sort U 0)
+(declare-fun f (U U) U)
+(declare-fun g (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(declare-fun d () U)
+(assert (or (= g (f a)) (= g (f b))))
+(assert (not (= (f a a) b)))
+(assert (not (= (f b a) c)))
+(assert (or (= (g a) b) (= (g a) c)))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic UF)
+(set-info :status unsat)
+(declare-sort U 0)
+(declare-fun f (U U) U)
+(declare-fun g (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(declare-fun d () U)
+(assert (or (= g (f a)) (= g (f b))))
+(assert (not (= (f a a) b)))
+(assert (not (= (f b a) b)))
+(assert (not (= (f a a) c)))
+(assert (not (= (f b a) c)))
+(assert (or (= (g a) b) (= (g a) c)))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+(declare-sort Msg$ 0)
+(declare-sort Nat$ 0)
+(declare-sort Agent$ 0)
+(declare-sort Event$ 0)
+(declare-sort Msg_set$ 0)
+(declare-sort Msg_list$ 0)
+(declare-sort Agent_set$ 0)
+(declare-sort Event_set$ 0)
+(declare-sort Agent_list$ 0)
+(declare-sort Event_list$ 0)
+(declare-sort Event_option$ 0)
+(declare-sort Msg_list_set$ 0)
+(declare-sort Agent_list_set$ 0)
+(declare-sort Event_list_set$ 0)
+(declare-sort Event_list_list$ 0)
+(declare-fun p$ () (-> Event$ Bool))
+(declare-fun uu$ ((-> Msg$ Bool) (-> Msg$ Bool) Msg$) Bool)
+(declare-fun bad$ () Agent_set$)
+(declare-fun nil$ () Event_list$)
+(declare-fun set$ (Event_list$) Event_set$)
+(declare-fun spy$ () Agent$)
+(declare-fun uua$ (Event_set$ (-> Event$ Bool) Event$) Bool)
+(declare-fun uub$ (Agent_set$ (-> Agent$ Bool) Agent$) Bool)
+(declare-fun uuc$ (Msg_set$ (-> Msg$ Bool) Msg$) Bool)
+(declare-fun uud$ (Event_set$ Event$) Bool)
+(declare-fun uue$ (Agent_set$ Agent$) Bool)
+(declare-fun uuf$ (Msg_set$ Msg$) Bool)
+(declare-fun uug$ (Event$ Event_list$) Bool)
+(declare-fun uuh$ (Event$ Event_list$) Bool)
+(declare-fun uui$ ((-> Event$ Bool) Event$ Event$) Bool)
+(declare-fun uuj$ (Event_list_set$ Event_list$ Event$) Bool)
+(declare-fun uuk$ (Msg$ (-> Msg$ Bool) Msg$) Bool)
+(declare-fun uul$ (Msg$ Msg_set$ Msg$) Bool)
+(declare-fun uum$ (Event$ Event_set$ Event$) Bool)
+(declare-fun uun$ (Agent$ Agent_set$ Agent$) Bool)
+(declare-fun uuo$ (Event_list$ Agent$ Agent$ Msg$) Msg_set$)
+(declare-fun uup$ (Event_list$ Agent$ Msg$) Msg_set$)
+(declare-fun uuq$ (Event_list$ Agent$ Msg$) Msg_set$)
+(declare-fun uur$ (Agent$ Event_list$ Agent$ Agent$ Msg$) Msg_set$)
+(declare-fun uus$ (Agent$ Event_list$ Agent$ Msg$) Msg_set$)
+(declare-fun bind$ (Event_list$ (-> Event$ Event_list$)) Event_list$)
+(declare-fun cons$ (Event$ Event_list$) Event_list$)
+(declare-fun gets$ (Agent$ Msg$) Event$)
+(declare-fun maps$ ((-> Event$ Event_list$)) (-> Event_list$ Event_list$))
+(declare-fun nil$a () Event_list_list$)
+(declare-fun nil$b () Msg_list$)
+(declare-fun nil$c () Agent_list$)
+(declare-fun null$ (Event_list$) Bool)
+(declare-fun says$ (Agent$ Agent$ Msg$) Event$)
+(declare-fun set$a (Msg_list$) Msg_set$)
+(declare-fun set$b (Agent_list$) Agent_set$)
+(declare-fun succ$ (Event_list_set$ Event_list$) Event_set$)
+(declare-fun cons$a (Event_list$ Event_list_list$) Event_list_list$)
+(declare-fun cons$b (Msg$ Msg_list$) Msg_list$)
+(declare-fun cons$c (Agent$ Agent_list$) Agent_list$)
+(declare-fun knows$ (Agent$ Event_list$) Msg_set$)
+(declare-fun notes$ (Agent$ Msg$) Event$)
+(declare-fun succ$a (Msg_list_set$ Msg_list$) Msg_set$)
+(declare-fun succ$b (Agent_list_set$ Agent_list$) Agent_set$)
+(declare-fun append$ (Event_list$ Event_list$) Event_list$)
+(declare-fun insert$ (Msg$ Msg_set$) Msg_set$)
+(declare-fun member$ (Agent$ Agent_set$) Bool)
+(declare-fun splice$ (Event_list$) (-> Event_list$ Event_list$))
+(declare-fun append$a (Msg_list$ Msg_list$) Msg_list$)
+(declare-fun append$b (Agent_list$ Agent_list$) Agent_list$)
+(declare-fun collect$ ((-> Msg$ Bool)) Msg_set$)
+(declare-fun insert$a (Event$) (-> Event_list$ Event_list$))
+(declare-fun insert$b (Event$ Event_set$) Event_set$)
+(declare-fun insert$c (Agent$ Agent_set$) Agent_set$)
+(declare-fun insert$d (Msg$ Msg_list$) Msg_list$)
+(declare-fun insert$e (Agent$ Agent_list$) Agent_list$)
+(declare-fun less_eq$ (Msg_set$ Msg_set$) Bool)
+(declare-fun list_ex$ ((-> Event$ Bool)) (-> Event_list$ Bool))
+(declare-fun member$a (Msg$ Msg_set$) Bool)
+(declare-fun member$b (Event$ Event_set$) Bool)
+(declare-fun member$c (Event_list$ Event_list_set$) Bool)
+(declare-fun member$d (Event_list$ Event$) Bool)
+(declare-fun member$e (Msg_list$ Msg_list_set$) Bool)
+(declare-fun member$f (Agent_list$ Agent_list_set$) Bool)
+(declare-fun member$g (Msg_list$ Msg$) Bool)
+(declare-fun member$h (Agent_list$ Agent$) Bool)
+(declare-fun rotate1$ (Event_list$) Event_list$)
+(declare-fun subseqs$ (Event_list$) Event_list_list$)
+(declare-fun antimono$ ((-> Msg_set$ Msg_set$)) Bool)
+(declare-fun collect$a ((-> Event$ Bool)) Event_set$)
+(declare-fun collect$b ((-> Agent$ Bool)) Agent_set$)
+(declare-fun greatest$ ((-> Msg_set$ Bool)) Msg_set$)
+(declare-fun less_eq$a (Event_set$ Event_set$) Bool)
+(declare-fun less_eq$b (Agent_set$ Agent_set$) Bool)
+(declare-fun less_eq$c ((-> Event$ Bool) (-> Event$ Bool)) Bool)
+(declare-fun less_eq$d ((-> Agent$ Bool) (-> Agent$ Bool)) Bool)
+(declare-fun less_eq$e ((-> Msg$ Bool) (-> Msg$ Bool)) Bool)
+(declare-fun less_eq$f ((-> Bool Msg_set$) (-> Bool Msg_set$)) Bool)
+(declare-fun list_all$ ((-> Event$ Bool) Event_list$) Bool)
+(declare-fun list_ex$a ((-> Msg$ Bool) Msg_list$) Bool)
+(declare-fun list_ex$b ((-> Agent$ Bool) Agent_list$) Bool)
+(declare-fun list_ex1$ ((-> Event$ Bool)) (-> Event_list$ Bool))
+(declare-fun case_list$ (Bool (-> Event$ (-> Event_list$ Bool)) Event_list$) Bool)
+(declare-fun initState$ (Agent$) Msg_set$)
+(declare-fun list_all$a ((-> Msg$ Bool) Msg_list$) Bool)
+(declare-fun list_all$b ((-> Agent$ Bool) Agent_list$) Bool)
+(declare-fun list_ex1$a ((-> Msg$ Bool) Msg_list$) Bool)
+(declare-fun list_ex1$b ((-> Agent$ Bool) Agent_list$) Bool)
+(declare-fun takeWhile$ ((-> Event$ Bool) Event_list$) Event_list$)
+(declare-fun case_event$ ((-> Agent$ (-> Agent$ (-> Msg$ Msg_set$))) (-> Agent$ (-> Msg$ Msg_set$)) (-> Agent$ (-> Msg$ Msg_set$)) Event$) Msg_set$)
+(declare-fun gen_length$ (Nat$) (-> Event_list$ Nat$))
+(declare-fun map_filter$ ((-> Event$ Event_option$)) (-> Event_list$ Event_list$))
+(declare-fun takeWhile$a ((-> Msg$ Bool) Msg_list$) Msg_list$)
+(declare-fun takeWhile$b ((-> Agent$ Bool) Agent_list$) Agent_list$)
+(declare-fun product_lists$ (Event_list_list$) Event_list_list$)
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent$)) (! (= (uue$ ?v0 ?v1) (member$ ?v1 ?v0)) :pattern ((uue$ ?v0 ?v1)))) :named a0))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (! (= (uuf$ ?v0 ?v1) (member$a ?v1 ?v0)) :pattern ((uuf$ ?v0 ?v1)))) :named a1))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event$)) (! (= (uud$ ?v0 ?v1) (member$b ?v1 ?v0)) :pattern ((uud$ ?v0 ?v1)))) :named a2))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uuq$ ?v0 ?v1 ?v2) (ite (member$ ?v1 bad$) (insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0))) :pattern ((uuq$ ?v0 ?v1 ?v2)))) :named a3))
+(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$) (?v2 Event$)) (! (= (uuj$ ?v0 ?v1 ?v2) (member$c (append$ ?v1 (cons$ ?v2 nil$)) ?v0)) :pattern ((uuj$ ?v0 ?v1 ?v2)))) :named a4))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (! (= (uun$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$ ?v2 ?v1))) :pattern ((uun$ ?v0 ?v1 ?v2)))) :named a5))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (! (= (uul$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$a ?v2 ?v1))) :pattern ((uul$ ?v0 ?v1 ?v2)))) :named a6))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (! (= (uum$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$b ?v2 ?v1))) :pattern ((uum$ ?v0 ?v1 ?v2)))) :named a7))
+(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool)) (?v2 Agent$)) (! (= (uub$ ?v0 ?v1 ?v2) (and (member$ ?v2 ?v0) (?v1 ?v2))) :pattern ((uub$ ?v0 ?v1 ?v2)))) :named a8))
+(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuc$ ?v0 ?v1 ?v2) (and (member$a ?v2 ?v0) (?v1 ?v2))) :pattern ((uuc$ ?v0 ?v1 ?v2)))) :named a9))
+(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool)) (?v2 Event$)) (! (= (uua$ ?v0 ?v1 ?v2) (and (member$b ?v2 ?v0) (?v1 ?v2))) :pattern ((uua$ ?v0 ?v1 ?v2)))) :named a10))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uu$ ?v0 ?v1 ?v2) (and (?v0 ?v2) (?v1 ?v2))) :pattern ((uu$ ?v0 ?v1 ?v2)))) :named a11))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuk$ ?v0 ?v1 ?v2) (=> (not (= ?v2 ?v0)) (?v1 ?v2))) :pattern ((uuk$ ?v0 ?v1 ?v2)))) :named a12))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event$)) (! (= (uui$ ?v0 ?v1 ?v2) (or (not (?v0 ?v2)) (= ?v1 ?v2))) :pattern ((uui$ ?v0 ?v1 ?v2)))) :named a13))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uup$ ?v0 ?v1 ?v2) (knows$ spy$ ?v0)) :pattern ((uup$ ?v0 ?v1 ?v2)))) :named a14))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (! (= (uus$ ?v0 ?v1 ?v2 ?v3) (ite (= ?v2 ?v0) (insert$ ?v3 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uus$ ?v0 ?v1 ?v2 ?v3)))) :named a15))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (! (= (uuo$ ?v0 ?v1 ?v2 ?v3) (insert$ ?v3 (knows$ spy$ ?v0))) :pattern ((uuo$ ?v0 ?v1 ?v2 ?v3)))) :named a16))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (! (= (uur$ ?v0 ?v1 ?v2 ?v3 ?v4) (ite (= ?v2 ?v0) (insert$ ?v4 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uur$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a17))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (uug$ ?v0 ?v1) false) :pattern ((uug$ ?v0 ?v1)))) :named a18))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (uuh$ ?v0 ?v1) true) :pattern ((uuh$ ?v0 ?v1)))) :named a19))
+(assert (! (not (less_eq$ (knows$ spy$ (takeWhile$ p$ nil$)) (knows$ spy$ nil$))) :named a20))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (takeWhile$ ?v0 (takeWhile$ ?v0 ?v1)) (takeWhile$ ?v0 ?v1))) :named a21))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (=> (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))) (less_eq$a ?v0 ?v1))) :named a22))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (=> (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))) (less_eq$b ?v0 ?v1))) :named a23))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))) (less_eq$ ?v0 ?v1))) :named a24))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a25))
+(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a26))
+(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (takeWhile$ ?v0 nil$) nil$) :pattern ((takeWhile$ ?v0)))) :named a27))
+(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 (-> Msg$ Bool))) (= (less_eq$ ?v0 (collect$ (uu$ ?v1 ?v2))) (and (less_eq$ ?v0 (collect$ ?v1)) (less_eq$ ?v0 (collect$ ?v2))))) :named a28))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$) (?v3 (-> Event$ Bool))) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 (collect$a (uua$ ?v2 ?v3)))) (?v3 ?v0))) :named a29))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$) (?v3 (-> Agent$ Bool))) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 (collect$b (uub$ ?v2 ?v3)))) (?v3 ?v0))) :named a30))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$) (?v3 (-> Msg$ Bool))) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 (collect$ (uuc$ ?v2 ?v3)))) (?v3 ?v0))) :named a31))
+(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool))) (less_eq$a (collect$a (uua$ ?v0 ?v1)) ?v0)) :named a32))
+(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool))) (less_eq$b (collect$b (uub$ ?v0 ?v1)) ?v0)) :named a33))
+(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool))) (less_eq$ (collect$ (uuc$ ?v0 ?v1)) ?v0)) :named a34))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (less_eq$a ?v0 ?v1) (forall ((?v4 Event$)) (=> (and (member$b ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$a (collect$a (uua$ ?v0 ?v2)) (collect$a (uua$ ?v1 ?v3))))) :named a35))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (less_eq$b ?v0 ?v1) (forall ((?v4 Agent$)) (=> (and (member$ ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$b (collect$b (uub$ ?v0 ?v2)) (collect$b (uub$ ?v1 ?v3))))) :named a36))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (less_eq$ ?v0 ?v1) (forall ((?v4 Msg$)) (=> (and (member$a ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$ (collect$ (uuc$ ?v0 ?v2)) (collect$ (uuc$ ?v1 ?v3))))) :named a37))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool))) (=> (less_eq$a ?v0 ?v1) (= (less_eq$a ?v0 (collect$a (uua$ ?v1 ?v2))) (forall ((?v3 Event$)) (=> (member$b ?v3 ?v0) (?v2 ?v3)))))) :named a38))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool))) (=> (less_eq$b ?v0 ?v1) (= (less_eq$b ?v0 (collect$b (uub$ ?v1 ?v2))) (forall ((?v3 Agent$)) (=> (member$ ?v3 ?v0) (?v2 ?v3)))))) :named a39))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool))) (=> (less_eq$ ?v0 ?v1) (= (less_eq$ ?v0 (collect$ (uuc$ ?v1 ?v2))) (forall ((?v3 Msg$)) (=> (member$a ?v3 ?v0) (?v2 ?v3)))))) :named a40))
+(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (=> (not (= ?v0 nil$)) false)) false)) :named a41))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a42))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a43))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a44))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (less_eq$c (uud$ ?v0) (uud$ ?v1)))) :named a45))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (less_eq$d (uue$ ?v0) (uue$ ?v1)))) :named a46))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (less_eq$e (uuf$ ?v0) (uuf$ ?v1)))) :named a47))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v1 ?v0))) :named a48))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v2 ?v0)) (less_eq$ ?v2 ?v1))) :named a49))
+(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a50))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a51))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a52))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (= ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a53))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (= ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a54))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (! (=> (less_eq$ ?v0 ?v1) (= (less_eq$ ?v1 ?v0) (= ?v1 ?v0))) :pattern ((less_eq$ ?v1 ?v0)))) :named a55))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a56))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v0 ?v1))) :named a57))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a58))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (= ?v0 ?v1) (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)))) :named a59))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg_set$ Msg_set$)) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (and (= (?v2 ?v1) ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v2 ?v4) (?v2 ?v5)))))) (less_eq$ (?v2 ?v0) ?v3))) :named a60))
+(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg_set$ Msg_set$)) (?v2 Msg_set$) (?v3 Msg_set$)) (=> (and (= ?v0 (?v1 ?v2)) (and (less_eq$ ?v2 ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v1 ?v4) (?v1 ?v5)))))) (less_eq$ ?v0 (?v1 ?v3)))) :named a61))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg_set$ Msg_set$)) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (and (less_eq$ (?v2 ?v1) ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v2 ?v4) (?v2 ?v5)))))) (less_eq$ (?v2 ?v0) ?v3))) :named a62))
+(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg_set$ Msg_set$)) (?v2 Msg_set$) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 (?v1 ?v2)) (and (less_eq$ ?v2 ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v1 ?v4) (?v1 ?v5)))))) (less_eq$ ?v0 (?v1 ?v3)))) :named a63))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool))) (= (less_eq$ (collect$ ?v0) (collect$ ?v1)) (forall ((?v2 Msg$)) (=> (?v0 ?v2) (?v1 ?v2))))) :named a64))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (not (member$b ?v2 ?v1))) (not (member$b ?v2 ?v0)))) :named a65))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (not (member$ ?v2 ?v1))) (not (member$ ?v2 ?v0)))) :named a66))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (not (member$a ?v2 ?v1))) (not (member$a ?v2 ?v0)))) :named a67))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (= ?v0 ?v1) (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)))) :named a68))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a69))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool))) (=> (forall ((?v2 Msg$)) (=> (?v0 ?v2) (?v1 ?v2))) (less_eq$ (collect$ ?v0) (collect$ ?v1)))) :named a70))
+(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a71))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (member$b ?v0 ?v2))) :named a72))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (member$ ?v0 ?v2))) :named a73))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (member$a ?v0 ?v2))) :named a74))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))))) :named a75))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))))) :named a76))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))))) :named a77))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (member$a ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a78))
+(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool))) (= (member$b ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a79))
+(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool))) (= (member$ ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a80))
+(assert (! (forall ((?v0 Msg_set$)) (= (collect$ (uuf$ ?v0)) ?v0)) :named a81))
+(assert (! (forall ((?v0 Event_set$)) (= (collect$a (uud$ ?v0)) ?v0)) :named a82))
+(assert (! (forall ((?v0 Agent_set$)) (= (collect$b (uue$ ?v0)) ?v0)) :named a83))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (member$b ?v0 ?v2))) :named a84))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (member$ ?v0 ?v2))) :named a85))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (member$a ?v0 ?v2))) :named a86))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v1 ?v0))) :named a87))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v0 ?v1))) :named a88))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))))) :named a89))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))))) :named a90))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))))) :named a91))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (= ?v0 ?v1) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) false)) false)) :named a92))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (and (=> (not (member$b ?v2 ?v0)) false) (=> (member$b ?v2 ?v1) false))) false)) :named a93))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (and (=> (not (member$ ?v2 ?v0)) false) (=> (member$ ?v2 ?v1) false))) false)) :named a94))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (and (=> (not (member$a ?v2 ?v0)) false) (=> (member$a ?v2 ?v1) false))) false)) :named a95))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a96))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a97))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a98))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a99))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a100))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a101))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$c (uud$ ?v0) (uud$ ?v1)) (less_eq$a ?v0 ?v1))) :named a102))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$d (uue$ ?v0) (uue$ ?v1)) (less_eq$b ?v0 ?v1))) :named a103))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$e (uuf$ ?v0) (uuf$ ?v1)) (less_eq$ ?v0 ?v1))) :named a104))
+(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (list_ex1$ ?v0 nil$) false) :pattern ((list_ex1$ ?v0)))) :named a105))
+(assert (! (forall ((?v0 (-> Event$ Event_list$))) (! (= (bind$ nil$ ?v0) nil$) :pattern ((bind$ nil$ ?v0)))) :named a106))
+(assert (! (forall ((?v0 (-> Msg_set$ Bool)) (?v1 Msg_set$)) (=> (and (?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (?v0 ?v2) (less_eq$ ?v2 ?v1)))) (= (greatest$ ?v0) ?v1))) :named a107))
+(assert (! (forall ((?v0 (-> Msg_set$ Bool)) (?v1 Msg_set$) (?v2 (-> Msg_set$ Bool))) (=> (and (?v0 ?v1) (and (forall ((?v3 Msg_set$)) (=> (?v0 ?v3) (less_eq$ ?v3 ?v1))) (forall ((?v3 Msg_set$)) (=> (and (?v0 ?v3) (forall ((?v4 Msg_set$)) (=> (?v0 ?v4) (less_eq$ ?v4 ?v3)))) (?v2 ?v3))))) (?v2 (greatest$ ?v0)))) :named a108))
+(assert (! (forall ((?v0 Event$)) (! (= (member$d nil$ ?v0) false) :pattern ((member$d nil$ ?v0)))) :named a109))
+(assert (! (forall ((?v0 (-> Bool Msg_set$)) (?v1 (-> Bool Msg_set$))) (! (= (less_eq$f ?v0 ?v1) (and (less_eq$ (?v0 false) (?v1 false)) (less_eq$ (?v0 true) (?v1 true)))) :pattern ((less_eq$f ?v0 ?v1)))) :named a110))
+(assert (! (forall ((?v0 Nat$)) (! (= (gen_length$ ?v0 nil$) ?v0) :pattern ((gen_length$ ?v0)))) :named a111))
+(assert (! (forall ((?v0 (-> Event$ Event_list$))) (! (= (maps$ ?v0 nil$) nil$) :pattern ((maps$ ?v0)))) :named a112))
+(assert (! (forall ((?v0 Event_list$)) (= (= ?v0 nil$) (null$ ?v0))) :named a113))
+(assert (! (= (null$ nil$) true) :named a114))
+(assert (! (forall ((?v0 Event_list$)) (! (= (splice$ ?v0 nil$) ?v0) :pattern ((splice$ ?v0)))) :named a115))
+(assert (! (forall ((?v0 Event_list$)) (= (= (rotate1$ ?v0) nil$) (= ?v0 nil$))) :named a116))
+(assert (! (forall ((?v0 (-> Event$ Event_option$))) (! (= (map_filter$ ?v0 nil$) nil$) :pattern ((map_filter$ ?v0)))) :named a117))
+(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$)) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (antimono$ ?v0) (less_eq$ ?v1 ?v2)) (less_eq$ (?v0 ?v2) (?v0 ?v1)))) :named a118))
+(assert (! (= (rotate1$ nil$) nil$) :named a119))
+(assert (! (forall ((?v0 Event_list$)) (! (= (splice$ nil$ ?v0) ?v0) :pattern ((splice$ nil$ ?v0)))) :named a120))
+(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$))) (= (antimono$ ?v0) (forall ((?v1 Msg_set$) (?v2 Msg_set$)) (=> (less_eq$ ?v1 ?v2) (less_eq$ (?v0 ?v2) (?v0 ?v1)))))) :named a121))
+(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$))) (=> (forall ((?v1 Msg_set$) (?v2 Msg_set$)) (=> (less_eq$ ?v1 ?v2) (less_eq$ (?v0 ?v2) (?v0 ?v1)))) (antimono$ ?v0))) :named a122))
+(assert (! (forall ((?v0 (-> Msg_set$ Msg_set$)) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (antimono$ ?v0) (and (less_eq$ ?v1 ?v2) (=> (less_eq$ (?v0 ?v2) (?v0 ?v1)) false))) false)) :named a123))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (=> (and (= (splice$ ?v0 ?v1) ?v2) (and (forall ((?v3 Event_list$)) (=> (and (= ?v0 nil$) (and (= ?v1 ?v3) (= ?v2 ?v3))) false)) (and (forall ((?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (cons$ ?v3 ?v4)) (and (= ?v1 nil$) (= ?v2 (cons$ ?v3 ?v4)))) false)) (forall ((?v3 Event$) (?v4 Event_list$) (?v5 Event$) (?v6 Event_list$)) (=> (and (= ?v0 (cons$ ?v3 ?v4)) (and (= ?v1 (cons$ ?v5 ?v6)) (= ?v2 (cons$ ?v3 (cons$ ?v5 (splice$ ?v4 ?v6)))))) false))))) false)) :named a124))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (splice$ (cons$ ?v0 ?v1) nil$) (cons$ ?v0 ?v1)) :pattern ((cons$ ?v0 ?v1)))) :named a125))
+(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (list_ex$ ?v0 nil$) false) :pattern ((list_ex$ ?v0)))) :named a126))
+(assert (! (forall ((?v0 Event_list$)) (= (= ?v0 nil$) (case_list$ true uug$ ?v0))) :named a127))
+(assert (! (forall ((?v0 Event_list$)) (= (not (= ?v0 nil$)) (case_list$ false uuh$ ?v0))) :named a128))
+(assert (! (forall ((?v0 Agent$)) (! (= (knows$ ?v0 nil$) (initState$ ?v0)) :pattern ((knows$ ?v0)))) :named a129))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (= (= (cons$ ?v0 ?v1) (cons$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a130))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (list_ex$ ?v0 (cons$ ?v1 ?v2)) (or (?v0 ?v1) (list_ex$ ?v0 ?v2))) :pattern ((list_ex$ ?v0 (cons$ ?v1 ?v2))))) :named a131))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (not (= (cons$ ?v0 ?v1) ?v1))) :named a132))
+(assert (! (forall ((?v0 Event_list_list$)) (=> (and (=> (= ?v0 nil$a) false) (and (forall ((?v1 Event_list_list$)) (=> (= ?v0 (cons$a nil$ ?v1)) false)) (forall ((?v1 Event$) (?v2 Event_list$) (?v3 Event_list_list$)) (=> (= ?v0 (cons$a (cons$ ?v1 ?v2) ?v3)) false)))) false)) :named a133))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (not (= nil$ (cons$ ?v0 ?v1)))) :named a134))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list$)) (=> (= ?v0 (cons$ ?v1 ?v2)) (not (= ?v0 nil$)))) :named a135))
+(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (forall ((?v1 Event$) (?v2 Event_list$)) (=> (= ?v0 (cons$ ?v1 ?v2)) false))) false)) :named a136))
+(assert (! (forall ((?v0 Event_list$)) (= (not (= ?v0 nil$)) (exists ((?v1 Event$) (?v2 Event_list$)) (= ?v0 (cons$ ?v1 ?v2))))) :named a137))
+(assert (! (forall ((?v0 (-> Event_list$ (-> Event_list$ Bool))) (?v1 Event_list$) (?v2 Event_list$)) (=> (and (?v0 nil$ nil$) (and (forall ((?v3 Event$) (?v4 Event_list$)) (?v0 (cons$ ?v3 ?v4) nil$)) (and (forall ((?v3 Event$) (?v4 Event_list$)) (?v0 nil$ (cons$ ?v3 ?v4))) (forall ((?v3 Event$) (?v4 Event_list$) (?v5 Event$) (?v6 Event_list$)) (=> (?v0 ?v4 ?v6) (?v0 (cons$ ?v3 ?v4) (cons$ ?v5 ?v6))))))) (?v0 ?v1 ?v2))) :named a138))
+(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (and (forall ((?v1 Event$)) (=> (= ?v0 (cons$ ?v1 nil$)) false)) (forall ((?v1 Event$) (?v2 Event$) (?v3 Event_list$)) (=> (= ?v0 (cons$ ?v1 (cons$ ?v2 ?v3))) false)))) false)) :named a139))
+(assert (! (forall ((?v0 (-> Event_list$ Bool)) (?v1 Event_list$)) (=> (and (?v0 nil$) (and (forall ((?v2 Event$)) (?v0 (cons$ ?v2 nil$))) (forall ((?v2 Event$) (?v3 Event$) (?v4 Event_list$)) (=> (?v0 (cons$ ?v3 ?v4)) (?v0 (cons$ ?v2 (cons$ ?v3 ?v4))))))) (?v0 ?v1))) :named a140))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event_list$ Bool))) (=> (and (not (= ?v0 nil$)) (and (forall ((?v2 Event$)) (?v1 (cons$ ?v2 nil$))) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (not (= ?v3 nil$)) (?v1 ?v3)) (?v1 (cons$ ?v2 ?v3)))))) (?v1 ?v0))) :named a141))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (! (= (splice$ (cons$ ?v0 ?v1) (cons$ ?v2 ?v3)) (cons$ ?v0 (cons$ ?v2 (splice$ ?v1 ?v3)))) :pattern ((splice$ (cons$ ?v0 ?v1) (cons$ ?v2 ?v3))))) :named a142))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Event$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ ?v2 ?v1)))) :named a143))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (null$ (cons$ ?v0 ?v1)) false) :pattern ((cons$ ?v0 ?v1)))) :named a144))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (! (= (member$d (cons$ ?v0 ?v1) ?v2) (or (= ?v0 ?v2) (member$d ?v1 ?v2))) :pattern ((member$d (cons$ ?v0 ?v1) ?v2)))) :named a145))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$)) (less_eq$ (initState$ ?v0) (knows$ ?v0 ?v1))) :named a146))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (takeWhile$ ?v0 (cons$ ?v1 ?v2)) (ite (?v0 ?v1) (cons$ ?v1 (takeWhile$ ?v0 ?v2)) nil$)) :pattern ((takeWhile$ ?v0 (cons$ ?v1 ?v2))))) :named a147))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (gets$ ?v1 ?v2) ?v0)))) :named a148))
+(assert (! (forall ((?v0 Event$)) (! (= (insert$a ?v0 nil$) (cons$ ?v0 nil$)) :pattern ((insert$a ?v0)))) :named a149))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (gets$ ?v0 ?v1) ?v2)) (knows$ spy$ ?v2)) :pattern ((cons$ (gets$ ?v0 ?v1) ?v2)))) :named a150))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (notes$ ?v1 ?v2) ?v0)))) :named a151))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (= (list_ex1$ ?v0 (cons$ ?v1 ?v2)) (ite (?v0 ?v1) (list_all$ (uui$ ?v0 ?v1) ?v2) (list_ex1$ ?v0 ?v2)))) :named a152))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Agent$) (?v3 Msg$)) (= (= (notes$ ?v0 ?v1) (notes$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a153))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Agent$) (?v3 Msg$)) (= (= (gets$ ?v0 ?v1) (gets$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a154))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (list_all$ ?v0 (cons$ ?v1 ?v2)) (and (?v0 ?v1) (list_all$ ?v0 ?v2))) :pattern ((list_all$ ?v0 (cons$ ?v1 ?v2))))) :named a155))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (list_all$ ?v0 (cons$ ?v1 ?v2)) (and (?v0 ?v1) (list_all$ ?v0 ?v2))) :pattern ((list_all$ ?v0 (cons$ ?v1 ?v2))))) :named a156))
+(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (list_all$ ?v0 nil$) true) :pattern ((list_all$ ?v0)))) :named a157))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Agent$) (?v3 Msg$)) (not (= (gets$ ?v0 ?v1) (notes$ ?v2 ?v3)))) :named a158))
+(assert (! (forall ((?v0 (-> Event$ Bool))) (list_all$ ?v0 nil$)) :named a159))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (notes$ ?v2 ?v3) ?v1)))) :named a160))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (gets$ ?v2 ?v3) ?v1)))) :named a161))
+(assert (! (= (product_lists$ nil$a) (cons$a nil$ nil$a)) :named a162))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (gets$ ?v1 ?v2) nil$))) (knows$ spy$ ?v0))) :named a163))
+(assert (! (= (subseqs$ nil$) (cons$a nil$ nil$a)) :named a164))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (says$ ?v1 ?v2 ?v3) ?v0)))) :named a165))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (append$ (append$ ?v0 ?v1) ?v2) (append$ ?v0 (append$ ?v1 ?v2)))) :named a166))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (append$ (append$ ?v0 ?v1) ?v2) (append$ ?v0 (append$ ?v1 ?v2)))) :named a167))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (= (append$ ?v0 ?v1) (append$ ?v2 ?v1)) (= ?v0 ?v2))) :named a168))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$)) (= (= (append$ ?v0 ?v1) (append$ ?v0 ?v2)) (= ?v1 ?v2))) :named a169))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Agent$) (?v4 Agent$) (?v5 Msg$)) (= (= (says$ ?v0 ?v1 ?v2) (says$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a170))
+(assert (! (forall ((?v0 Event_list$)) (! (= (append$ ?v0 nil$) ?v0) :pattern ((append$ ?v0)))) :named a171))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= (append$ ?v0 ?v1) ?v0) (= ?v1 nil$))) :named a172))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= ?v0 (append$ ?v0 ?v1)) (= ?v1 nil$))) :named a173))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= (append$ ?v0 ?v1) ?v1) (= ?v0 nil$))) :named a174))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= ?v0 (append$ ?v1 ?v0)) (= ?v1 nil$))) :named a175))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= nil$ (append$ ?v0 ?v1)) (and (= ?v0 nil$) (= ?v1 nil$)))) :named a176))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (= (= (append$ ?v0 ?v1) nil$) (and (= ?v0 nil$) (= ?v1 nil$)))) :named a177))
+(assert (! (forall ((?v0 Event_list$)) (! (= (append$ ?v0 nil$) ?v0) :pattern ((append$ ?v0)))) :named a178))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 Event_list$)) (= (list_all$ ?v0 (append$ ?v1 ?v2)) (and (list_all$ ?v0 ?v1) (list_all$ ?v0 ?v2)))) :named a179))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 Event_list$)) (= (list_ex$ ?v0 (append$ ?v1 ?v2)) (or (list_ex$ ?v0 ?v1) (list_ex$ ?v0 ?v2)))) :named a180))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list$) (?v3 Event$)) (= (= (append$ ?v0 (cons$ ?v1 nil$)) (append$ ?v2 (cons$ ?v3 nil$))) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a181))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 (-> Event$ Event_list$))) (! (= (bind$ (cons$ ?v0 ?v1) ?v2) (append$ (?v2 ?v0) (bind$ ?v1 ?v2))) :pattern ((bind$ (cons$ ?v0 ?v1) ?v2)))) :named a182))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$)) (! (= (append$ (cons$ ?v0 ?v1) ?v2) (cons$ ?v0 (append$ ?v1 ?v2))) :pattern ((append$ (cons$ ?v0 ?v1) ?v2)))) :named a183))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (= (cons$ ?v0 ?v1) ?v2) (= ?v3 (append$ ?v1 ?v4))) (= (cons$ ?v0 ?v3) (append$ ?v2 ?v4)))) :named a184))
+(assert (! (forall ((?v0 Event_list$)) (! (= (append$ nil$ ?v0) ?v0) :pattern ((append$ nil$ ?v0)))) :named a185))
+(assert (! (forall ((?v0 Event_list$)) (! (= (append$ nil$ ?v0) ?v0) :pattern ((append$ nil$ ?v0)))) :named a186))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$)) (=> (= ?v0 ?v1) (= ?v0 (append$ nil$ ?v1)))) :named a187))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (= (append$ ?v0 ?v1) ?v2) (= ?v3 (append$ ?v1 ?v4))) (= (append$ ?v0 ?v3) (append$ ?v2 ?v4)))) :named a188))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$)) (= (= (append$ ?v0 ?v1) (append$ ?v2 ?v3)) (exists ((?v4 Event_list$)) (or (and (= ?v0 (append$ ?v2 ?v4)) (= (append$ ?v4 ?v1) ?v3)) (and (= (append$ ?v0 ?v4) ?v2) (= ?v1 (append$ ?v4 ?v3))))))) :named a189))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Agent$) (?v4 Msg$)) (not (= (says$ ?v0 ?v1 ?v2) (notes$ ?v3 ?v4)))) :named a190))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Agent$) (?v4 Msg$)) (not (= (says$ ?v0 ?v1 ?v2) (gets$ ?v3 ?v4)))) :named a191))
+(assert (! (forall ((?v0 (-> Event_list$ Bool)) (?v1 Event_list$)) (=> (and (?v0 nil$) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (?v0 ?v3) (?v0 (append$ ?v3 (cons$ ?v2 nil$)))))) (?v0 ?v1))) :named a192))
+(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (forall ((?v1 Event_list$) (?v2 Event$)) (=> (= ?v0 (append$ ?v1 (cons$ ?v2 nil$))) false))) false)) :named a193))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$)) (= (= (cons$ ?v0 ?v1) (append$ ?v2 ?v3)) (or (and (= ?v2 nil$) (= (cons$ ?v0 ?v1) ?v3)) (exists ((?v4 Event_list$)) (and (= (cons$ ?v0 ?v4) ?v2) (= ?v1 (append$ ?v4 ?v3))))))) :named a194))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (= (= (append$ ?v0 ?v1) (cons$ ?v2 ?v3)) (or (and (= ?v0 nil$) (= ?v1 (cons$ ?v2 ?v3))) (exists ((?v4 Event_list$)) (and (= ?v0 (cons$ ?v2 ?v4)) (= (append$ ?v4 ?v1) ?v3)))))) :named a195))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event_list$ Bool))) (=> (and (not (= ?v0 nil$)) (and (forall ((?v2 Event$)) (?v1 (cons$ ?v2 nil$))) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (not (= ?v3 nil$)) (?v1 ?v3)) (?v1 (append$ ?v3 (cons$ ?v2 nil$))))))) (?v1 ?v0))) :named a196))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$) (?v3 Event_list$)) (=> (not (?v0 ?v1)) (= (takeWhile$ ?v0 (append$ ?v2 (cons$ ?v1 ?v3))) (takeWhile$ ?v0 ?v2)))) :named a197))
+(assert (! (forall ((?v0 Event$)) (=> (and (forall ((?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (=> (= ?v0 (says$ ?v1 ?v2 ?v3)) false)) (and (forall ((?v1 Agent$) (?v2 Msg$)) (=> (= ?v0 (gets$ ?v1 ?v2)) false)) (forall ((?v1 Agent$) (?v2 Msg$)) (=> (= ?v0 (notes$ ?v1 ?v2)) false)))) false)) :named a198))
+(assert (! (forall ((?v0 (-> Event$ Event_list$)) (?v1 Event$) (?v2 Event_list$)) (! (= (maps$ ?v0 (cons$ ?v1 ?v2)) (append$ (?v0 ?v1) (maps$ ?v0 ?v2))) :pattern ((maps$ ?v0 (cons$ ?v1 ?v2))))) :named a199))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (rotate1$ (cons$ ?v0 ?v1)) (append$ ?v1 (cons$ ?v0 nil$)))) :named a200))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (says$ ?v2 ?v3 ?v4) ?v1)))) :named a201))
+(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$)) (= (succ$ ?v0 ?v1) (collect$a (uuj$ ?v0 ?v1)))) :named a202))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (says$ ?v1 ?v2 ?v3) nil$))) (insert$ ?v3 (knows$ spy$ ?v0)))) :named a203))
+(assert (! (forall ((?v0 Msg$) (?v1 Agent$) (?v2 Event_list$)) (=> (and (member$a ?v0 (knows$ ?v1 ?v2)) (not (= ?v1 spy$))) (exists ((?v3 Agent$)) (or (member$b (says$ ?v1 ?v3 ?v0) (set$ ?v2)) (or (member$b (gets$ ?v1 ?v0) (set$ ?v2)) (or (member$b (notes$ ?v1 ?v0) (set$ ?v2)) (member$a ?v0 (initState$ ?v1)))))))) :named a204))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list_set$) (?v2 Msg_list$)) (=> (member$a ?v0 (succ$a ?v1 ?v2)) (member$e (append$a ?v2 (cons$b ?v0 nil$b)) ?v1))) :named a205))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list_set$) (?v2 Agent_list$)) (=> (member$ ?v0 (succ$b ?v1 ?v2)) (member$f (append$b ?v2 (cons$c ?v0 nil$c)) ?v1))) :named a206))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list_set$) (?v2 Event_list$)) (=> (member$b ?v0 (succ$ ?v1 ?v2)) (member$c (append$ ?v2 (cons$ ?v0 nil$)) ?v1))) :named a207))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (insert$ ?v0 (insert$ ?v0 ?v1)) (insert$ ?v0 ?v1))) :named a208))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (member$a ?v0 (insert$ ?v1 ?v2)) (or (= ?v0 ?v1) (member$a ?v0 ?v2)))) :named a209))
+(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (= (member$b ?v0 (insert$b ?v1 ?v2)) (or (= ?v0 ?v1) (member$b ?v0 ?v2)))) :named a210))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (= (member$ ?v0 (insert$c ?v1 ?v2)) (or (= ?v0 ?v1) (member$ ?v0 ?v2)))) :named a211))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (=> (not (member$a ?v0 ?v1)) (= ?v0 ?v2)) (member$a ?v0 (insert$ ?v2 ?v1)))) :named a212))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (=> (not (member$b ?v0 ?v1)) (= ?v0 ?v2)) (member$b ?v0 (insert$b ?v2 ?v1)))) :named a213))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (=> (not (member$ ?v0 ?v1)) (= ?v0 ?v2)) (member$ ?v0 (insert$c ?v2 ?v1)))) :named a214))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (= (less_eq$a (insert$b ?v0 ?v1) ?v2) (and (member$b ?v0 ?v2) (less_eq$a ?v1 ?v2)))) :named a215))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (= (less_eq$b (insert$c ?v0 ?v1) ?v2) (and (member$ ?v0 ?v2) (less_eq$b ?v1 ?v2)))) :named a216))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (= (less_eq$ (insert$ ?v0 ?v1) ?v2) (and (member$a ?v0 ?v2) (less_eq$ ?v1 ?v2)))) :named a217))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (= (takeWhile$a ?v0 ?v1) ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 (set$a ?v1)) (?v0 ?v2))))) :named a218))
+(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (= (takeWhile$b ?v0 ?v1) ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 (set$b ?v1)) (?v0 ?v2))))) :named a219))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (= (takeWhile$ ?v0 ?v1) ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 (set$ ?v1)) (?v0 ?v2))))) :named a220))
+(assert (! (forall ((?v0 Event_list$)) (= (set$ (rotate1$ ?v0)) (set$ ?v0))) :named a221))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (member$a ?v0 (set$a ?v1)) (= (insert$d ?v0 ?v1) ?v1)) :pattern ((insert$d ?v0 ?v1)))) :named a222))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (member$ ?v0 (set$b ?v1)) (= (insert$e ?v0 ?v1) ?v1)) :pattern ((insert$e ?v0 ?v1)))) :named a223))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (member$b ?v0 (set$ ?v1)) (= (insert$a ?v0 ?v1) ?v1)) :pattern ((insert$a ?v0 ?v1)))) :named a224))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (set$a (cons$b ?v0 ?v1)) (insert$ ?v0 (set$a ?v1))) :pattern ((cons$b ?v0 ?v1)))) :named a225))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (set$ (cons$ ?v0 ?v1)) (insert$b ?v0 (set$ ?v1))) :pattern ((cons$ ?v0 ?v1)))) :named a226))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (forall ((?v3 Msg$)) (=> (member$a ?v3 (set$a ?v0)) (?v1 ?v3))) (= (takeWhile$a ?v1 (append$a ?v0 ?v2)) (append$a ?v0 (takeWhile$a ?v1 ?v2))))) :named a227))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (forall ((?v3 Agent$)) (=> (member$ ?v3 (set$b ?v0)) (?v1 ?v3))) (= (takeWhile$b ?v1 (append$b ?v0 ?v2)) (append$b ?v0 (takeWhile$b ?v1 ?v2))))) :named a228))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (forall ((?v3 Event$)) (=> (member$b ?v3 (set$ ?v0)) (?v1 ?v3))) (= (takeWhile$ ?v1 (append$ ?v0 ?v2)) (append$ ?v0 (takeWhile$ ?v1 ?v2))))) :named a229))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 Msg_list$)) (=> (and (member$a ?v0 (set$a ?v1)) (not (?v2 ?v0))) (= (takeWhile$a ?v2 (append$a ?v1 ?v3)) (takeWhile$a ?v2 ?v1)))) :named a230))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 Agent_list$)) (=> (and (member$ ?v0 (set$b ?v1)) (not (?v2 ?v0))) (= (takeWhile$b ?v2 (append$b ?v1 ?v3)) (takeWhile$b ?v2 ?v1)))) :named a231))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 Event_list$)) (=> (and (member$b ?v0 (set$ ?v1)) (not (?v2 ?v0))) (= (takeWhile$ ?v2 (append$ ?v1 ?v3)) (takeWhile$ ?v2 ?v1)))) :named a232))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set$a (insert$d ?v0 ?v1)) (insert$ ?v0 (set$a ?v1)))) :named a233))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set$ (insert$a ?v0 ?v1)) (insert$b ?v0 (set$ ?v1)))) :named a234))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (not (member$a ?v0 (set$a ?v1))) (= (insert$d ?v0 ?v1) (cons$b ?v0 ?v1))) :pattern ((insert$d ?v0 ?v1)))) :named a235))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (not (member$ ?v0 (set$b ?v1))) (= (insert$e ?v0 ?v1) (cons$c ?v0 ?v1))) :pattern ((insert$e ?v0 ?v1)))) :named a236))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (not (member$b ?v0 (set$ ?v1))) (= (insert$a ?v0 ?v1) (cons$ ?v0 ?v1))) :pattern ((insert$a ?v0 ?v1)))) :named a237))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (! (= (knows$ spy$ (cons$ (says$ ?v0 ?v1 ?v2) ?v3)) (insert$ ?v2 (knows$ spy$ ?v3))) :pattern ((cons$ (says$ ?v0 ?v1 ?v2) ?v3)))) :named a238))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_set$)) (= (less_eq$b (set$b ?v0) ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 (set$b ?v0)) (member$ ?v2 ?v1))))) :named a239))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_set$)) (= (less_eq$a (set$ ?v0) ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 (set$ ?v0)) (member$b ?v2 ?v1))))) :named a240))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_set$)) (= (less_eq$ (set$a ?v0) ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 (set$a ?v0)) (member$a ?v2 ?v1))))) :named a241))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v2 ?v1)) (less_eq$a (insert$b ?v0 ?v2) ?v1))) :named a242))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v2 ?v1)) (less_eq$b (insert$c ?v0 ?v2) ?v1))) :named a243))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v2 ?v1)) (less_eq$ (insert$ ?v0 ?v2) ?v1))) :named a244))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ ?v0 (insert$ ?v2 ?v1)))) :named a245))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (less_eq$ ?v0 (insert$ ?v1 ?v0))) :named a246))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (not (member$b ?v0 ?v1)) (= (less_eq$a ?v1 (insert$b ?v0 ?v2)) (less_eq$a ?v1 ?v2)))) :named a247))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (not (member$ ?v0 ?v1)) (= (less_eq$b ?v1 (insert$c ?v0 ?v2)) (less_eq$b ?v1 ?v2)))) :named a248))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (not (member$a ?v0 ?v1)) (= (less_eq$ ?v1 (insert$ ?v0 ?v2)) (less_eq$ ?v1 ?v2)))) :named a249))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ (insert$ ?v2 ?v0) (insert$ ?v2 ?v1)))) :named a250))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$a ?v2 ?v0) (list_ex$a ?v3 ?v1)))) :named a251))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$b ?v2 ?v0) (list_ex$b ?v3 ?v1)))) :named a252))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$ ?v2 ?v0) (list_ex$ ?v3 ?v1)))) :named a253))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (insert$ ?v0 (collect$ ?v1)) (collect$ (uuk$ ?v0 ?v1)))) :named a254))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (insert$ ?v0 ?v1) (collect$ (uul$ ?v0 ?v1)))) :named a255))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (= (insert$b ?v0 ?v1) (collect$a (uum$ ?v0 ?v1)))) :named a256))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (= (insert$c ?v0 ?v1) (collect$b (uun$ ?v0 ?v1)))) :named a257))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (member$a ?v0 ?v1) (exists ((?v2 Msg_set$)) (and (= ?v1 (insert$ ?v0 ?v2)) (not (member$a ?v0 ?v2)))))) :named a258))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (member$b ?v0 ?v1) (exists ((?v2 Event_set$)) (and (= ?v1 (insert$b ?v0 ?v2)) (not (member$b ?v0 ?v2)))))) :named a259))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (member$ ?v0 ?v1) (exists ((?v2 Agent_set$)) (and (= ?v1 (insert$c ?v0 ?v2)) (not (member$ ?v0 ?v2)))))) :named a260))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (insert$ ?v0 (insert$ ?v1 ?v2)) (insert$ ?v1 (insert$ ?v0 ?v2)))) :named a261))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$) (?v3 Msg_set$)) (=> (and (not (member$a ?v0 ?v1)) (not (member$a ?v2 ?v3))) (= (= (insert$ ?v0 ?v1) (insert$ ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Msg_set$)) (and (= ?v1 (insert$ ?v2 ?v4)) (and (not (member$a ?v2 ?v4)) (and (= ?v3 (insert$ ?v0 ?v4)) (not (member$a ?v0 ?v4)))))))))) :named a262))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$) (?v3 Event_set$)) (=> (and (not (member$b ?v0 ?v1)) (not (member$b ?v2 ?v3))) (= (= (insert$b ?v0 ?v1) (insert$b ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Event_set$)) (and (= ?v1 (insert$b ?v2 ?v4)) (and (not (member$b ?v2 ?v4)) (and (= ?v3 (insert$b ?v0 ?v4)) (not (member$b ?v0 ?v4)))))))))) :named a263))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$) (?v3 Agent_set$)) (=> (and (not (member$ ?v0 ?v1)) (not (member$ ?v2 ?v3))) (= (= (insert$c ?v0 ?v1) (insert$c ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Agent_set$)) (and (= ?v1 (insert$c ?v2 ?v4)) (and (not (member$ ?v2 ?v4)) (and (= ?v3 (insert$c ?v0 ?v4)) (not (member$ ?v0 ?v4)))))))))) :named a264))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (! (=> (member$a ?v0 ?v1) (= (insert$ ?v0 ?v1) ?v1)) :pattern ((insert$ ?v0 ?v1)))) :named a265))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (! (=> (member$b ?v0 ?v1) (= (insert$b ?v0 ?v1) ?v1)) :pattern ((insert$b ?v0 ?v1)))) :named a266))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (! (=> (member$ ?v0 ?v1) (= (insert$c ?v0 ?v1) ?v1)) :pattern ((insert$c ?v0 ?v1)))) :named a267))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (not (member$a ?v0 ?v1)) (not (member$a ?v0 ?v2))) (= (= (insert$ ?v0 ?v1) (insert$ ?v0 ?v2)) (= ?v1 ?v2)))) :named a268))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (not (member$b ?v0 ?v1)) (not (member$b ?v0 ?v2))) (= (= (insert$b ?v0 ?v1) (insert$b ?v0 ?v2)) (= ?v1 ?v2)))) :named a269))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (not (member$ ?v0 ?v1)) (not (member$ ?v0 ?v2))) (= (= (insert$c ?v0 ?v1) (insert$c ?v0 ?v2)) (= ?v1 ?v2)))) :named a270))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (and (member$a ?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (and (= ?v1 (insert$ ?v0 ?v2)) (not (member$a ?v0 ?v2))) false))) false)) :named a271))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (and (member$b ?v0 ?v1) (forall ((?v2 Event_set$)) (=> (and (= ?v1 (insert$b ?v0 ?v2)) (not (member$b ?v0 ?v2))) false))) false)) :named a272))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (and (member$ ?v0 ?v1) (forall ((?v2 Agent_set$)) (=> (and (= ?v1 (insert$c ?v0 ?v2)) (not (member$ ?v0 ?v2))) false))) false)) :named a273))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (member$a ?v0 ?v1) (member$a ?v0 (insert$ ?v2 ?v1)))) :named a274))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (member$b ?v0 ?v1) (member$b ?v0 (insert$b ?v2 ?v1)))) :named a275))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (member$ ?v0 ?v1) (member$ ?v0 (insert$c ?v2 ?v1)))) :named a276))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (member$a ?v0 (insert$ ?v0 ?v1))) :named a277))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (member$b ?v0 (insert$b ?v0 ?v1))) :named a278))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (member$ ?v0 (insert$c ?v0 ?v1))) :named a279))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (=> (and (member$a ?v0 (insert$ ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$a ?v0 ?v2) false))) false)) :named a280))
+(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (=> (and (member$b ?v0 (insert$b ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$b ?v0 ?v2) false))) false)) :named a281))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (=> (and (member$ ?v0 (insert$c ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$ ?v0 ?v2) false))) false)) :named a282))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (member$a ?v0 (set$a (takeWhile$a ?v1 ?v2))) (and (member$a ?v0 (set$a ?v2)) (?v1 ?v0)))) :named a283))
+(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (member$ ?v0 (set$b (takeWhile$b ?v1 ?v2))) (and (member$ ?v0 (set$b ?v2)) (?v1 ?v0)))) :named a284))
+(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (member$b ?v0 (set$ (takeWhile$ ?v1 ?v2))) (and (member$b ?v0 (set$ ?v2)) (?v1 ?v0)))) :named a285))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$a ?v2 ?v0) (takeWhile$a ?v3 ?v1)))) :named a286))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$b ?v2 ?v0) (takeWhile$b ?v3 ?v1)))) :named a287))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$ ?v2 ?v0) (takeWhile$ ?v3 ?v1)))) :named a288))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg$)) (=> (member$a ?v0 (set$a ?v1)) (member$a ?v0 (set$a (cons$b ?v2 ?v1))))) :named a289))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent$)) (=> (member$ ?v0 (set$b ?v1)) (member$ ?v0 (set$b (cons$c ?v2 ?v1))))) :named a290))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (=> (member$b ?v0 (set$ ?v1)) (member$b ?v0 (set$ (cons$ ?v2 ?v1))))) :named a291))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (member$a ?v0 (set$a (cons$b ?v0 ?v1)))) :named a292))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (member$ ?v0 (set$b (cons$c ?v0 ?v1)))) :named a293))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (member$b ?v0 (set$ (cons$ ?v0 ?v1)))) :named a294))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_list$)) (=> (member$a ?v0 (set$a (cons$b ?v1 ?v2))) (or (= ?v0 ?v1) (member$a ?v0 (set$a ?v2))))) :named a295))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_list$)) (=> (member$ ?v0 (set$b (cons$c ?v1 ?v2))) (or (= ?v0 ?v1) (member$ ?v0 (set$b ?v2))))) :named a296))
+(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_list$)) (=> (member$b ?v0 (set$ (cons$ ?v1 ?v2))) (or (= ?v0 ?v1) (member$b ?v0 (set$ ?v2))))) :named a297))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (and (member$a ?v0 (set$a ?v1)) (and (forall ((?v2 Msg_list$)) (=> (= ?v1 (cons$b ?v0 ?v2)) false)) (forall ((?v2 Msg$) (?v3 Msg_list$)) (=> (and (= ?v1 (cons$b ?v2 ?v3)) (member$a ?v0 (set$a ?v3))) false)))) false)) :named a298))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (and (member$ ?v0 (set$b ?v1)) (and (forall ((?v2 Agent_list$)) (=> (= ?v1 (cons$c ?v0 ?v2)) false)) (forall ((?v2 Agent$) (?v3 Agent_list$)) (=> (and (= ?v1 (cons$c ?v2 ?v3)) (member$ ?v0 (set$b ?v3))) false)))) false)) :named a299))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (and (member$b ?v0 (set$ ?v1)) (and (forall ((?v2 Event_list$)) (=> (= ?v1 (cons$ ?v0 ?v2)) false)) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (= ?v1 (cons$ ?v2 ?v3)) (member$b ?v0 (set$ ?v3))) false)))) false)) :named a300))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$a ?v2 ?v0) (list_all$a ?v3 ?v1)))) :named a301))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$b ?v2 ?v0) (list_all$b ?v3 ?v1)))) :named a302))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$ ?v2 ?v0) (list_all$ ?v3 ?v1)))) :named a303))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$) (?v2 (-> Msg$ Bool))) (=> (and (list_all$a ?v0 ?v1) (forall ((?v3 Msg$)) (=> (and (member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$a ?v2 ?v1))) :named a304))
+(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$) (?v2 (-> Agent$ Bool))) (=> (and (list_all$b ?v0 ?v1) (forall ((?v3 Agent$)) (=> (and (member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$b ?v2 ?v1))) :named a305))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 (-> Event$ Bool))) (=> (and (list_all$ ?v0 ?v1) (forall ((?v3 Event$)) (=> (and (member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$ ?v2 ?v1))) :named a306))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (list_ex1$a ?v0 ?v1) (exists ((?v2 Msg$)) (and (and (member$a ?v2 (set$a ?v1)) (?v0 ?v2)) (forall ((?v3 Msg$)) (=> (and (member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a307))
+(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (list_ex1$b ?v0 ?v1) (exists ((?v2 Agent$)) (and (and (member$ ?v2 (set$b ?v1)) (?v0 ?v2)) (forall ((?v3 Agent$)) (=> (and (member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a308))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (list_ex1$ ?v0 ?v1) (exists ((?v2 Event$)) (and (and (member$b ?v2 (set$ ?v1)) (?v0 ?v2)) (forall ((?v3 Event$)) (=> (and (member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a309))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (member$g ?v1 ?v0))) :named a310))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (member$h ?v1 ?v0))) :named a311))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (member$d ?v1 ?v0))) :named a312))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event$)) (less_eq$a (set$ ?v0) (set$ (cons$ ?v1 ?v0)))) :named a313))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$)) (less_eq$ (set$a ?v0) (set$a (cons$b ?v1 ?v0)))) :named a314))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a315))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a316))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a317))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a318))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a319))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a320))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v2))))))) :named a321))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v2))))))) :named a322))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v2))))))) :named a323))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v3))))))) :named a324))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v3))))))) :named a325))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v3))))))) :named a326))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a327))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a328))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a329))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a330))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a331))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a332))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a333))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a334))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a335))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a336))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a337))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a338))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a339))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a340))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a341))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg_list$) (?v3 Msg_list$) (?v4 Msg_list$)) (=> (and (not (member$a ?v0 (set$a ?v1))) (not (member$a ?v0 (set$a ?v2)))) (= (= (append$a ?v1 (cons$b ?v0 ?v2)) (append$a ?v3 (cons$b ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a342))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent_list$) (?v3 Agent_list$) (?v4 Agent_list$)) (=> (and (not (member$ ?v0 (set$b ?v1))) (not (member$ ?v0 (set$b ?v2)))) (= (= (append$b ?v1 (cons$c ?v0 ?v2)) (append$b ?v3 (cons$c ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a343))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (not (member$b ?v0 (set$ ?v1))) (not (member$b ?v0 (set$ ?v2)))) (= (= (append$ ?v1 (cons$ ?v0 ?v2)) (append$ ?v3 (cons$ ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a344))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a345))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a346))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a347))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v2))))))) :named a348))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v2))))))) :named a349))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v2))))))) :named a350))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3))))) :named a351))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3))))) :named a352))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3))))) :named a353))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v3))))))) :named a354))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v3))))))) :named a355))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v3))))))) :named a356))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a357))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a358))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a359))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (member$a ?v2 (knows$ ?v0 ?v3)))) :named a360))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (member$b (notes$ ?v0 ?v1) (set$ ?v2)) (member$a ?v1 (knows$ ?v0 ?v2)))) :named a361))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (insert$d ?v0 ?v1) (ite (member$a ?v0 (set$a ?v1)) ?v1 (cons$b ?v0 ?v1))) :pattern ((insert$d ?v0 ?v1)))) :named a362))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (= (insert$e ?v0 ?v1) (ite (member$ ?v0 (set$b ?v1)) ?v1 (cons$c ?v0 ?v1))) :pattern ((insert$e ?v0 ?v1)))) :named a363))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (insert$a ?v0 ?v1) (ite (member$b ?v0 (set$ ?v1)) ?v1 (cons$ ?v0 ?v1))) :pattern ((insert$a ?v0 ?v1)))) :named a364))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (member$a ?v2 (knows$ spy$ ?v3)))) :named a365))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (not (= ?v0 spy$)) (member$b (gets$ ?v0 ?v1) (set$ ?v2))) (member$a ?v1 (knows$ ?v0 ?v2)))) :named a366))
+(assert (! (forall ((?v0 Msg$) (?v1 Event_list$)) (=> (member$a ?v0 (knows$ spy$ ?v1)) (exists ((?v2 Agent$) (?v3 Agent$)) (or (member$b (says$ ?v2 ?v3 ?v0) (set$ ?v1)) (or (member$b (notes$ ?v2 ?v0) (set$ ?v1)) (member$a ?v0 (initState$ spy$))))))) :named a367))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$) (?v2 Msg_list_set$)) (=> (member$e (append$a ?v0 (cons$b ?v1 nil$b)) ?v2) (member$a ?v1 (succ$a ?v2 ?v0)))) :named a368))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent$) (?v2 Agent_list_set$)) (=> (member$f (append$b ?v0 (cons$c ?v1 nil$c)) ?v2) (member$ ?v1 (succ$b ?v2 ?v0)))) :named a369))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list_set$)) (=> (member$c (append$ ?v0 (cons$ ?v1 nil$)) ?v2) (member$b ?v1 (succ$ ?v2 ?v0)))) :named a370))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (notes$ ?v1 ?v2) nil$))) (ite (member$ ?v1 bad$) (insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0)))) :named a371))
+(assert (! (member$ spy$ bad$) :named a372))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (notes$ ?v0 ?v1) ?v2)) (ite (member$ ?v0 bad$) (insert$ ?v1 (knows$ spy$ ?v2)) (knows$ spy$ ?v2))) :pattern ((cons$ (notes$ ?v0 ?v1) ?v2)))) :named a373))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (member$b (notes$ ?v0 ?v1) (set$ ?v2)) (member$ ?v0 bad$)) (member$a ?v1 (knows$ spy$ ?v2)))) :named a374))
+(assert (! (forall ((?v0 Agent$) (?v1 Event$) (?v2 Event_list$)) (= (knows$ ?v0 (cons$ ?v1 ?v2)) (ite (= ?v0 spy$) (case_event$ (uuo$ ?v2) (uup$ ?v2) (uuq$ ?v2) ?v1) (case_event$ (uur$ ?v0 ?v2) (uus$ ?v0 ?v2) (uus$ ?v0 ?v2) ?v1)))) :named a375))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic UFLIA)
+(set-info :status unsat)
+(declare-fun f (Int) Int)
+(declare-fun g (Int) Int)
+(declare-fun h (Int) Int)
+
+(assert (not (= (f 0) (g 0))))
+(assert (not (= (f 0) (h 0))))
+(assert (or (= f g) (= f h)))
+
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic UF)
+(set-info :status unsat)
+(declare-sort U 0)
+(declare-fun f (U) U)
+(declare-fun g (U) U)
+(declare-fun h (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(assert (or (= f h) (= f g)))
+(assert (not (= (f a) (g a))))
+(assert (not (= (f a) (h a))))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic ALL)
+(set-info :status sat)
+(declare-fun f (Int Int) Int)
+(declare-fun g (Int) (-> Int Int))
+(declare-fun h () (-> Int Int Int))
+
+(assert (and (= f g) (= g h)))
+
+(assert (= (f 1 2) 5))
+(assert (= (f 2 1) 7))
+
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+(declare-fun f (Int Int) Int)
+(define-fun g ((x Int)) (-> Int Int) (f x))
+
+(declare-fun a () Int)
+(declare-fun b () Int)
+
+(assert (not (= (g a b) (f a b))))
+
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic UF)
+(set-info :status unsat)
+(declare-sort U 0)
+(declare-fun f (U) U)
+(declare-fun g (U) U)
+(declare-fun h (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(assert (distinct f g h))
+(assert (forall ((x U) (y U)) (= x y)))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic ALL)
+(set-info :status sat)
+(declare-sort U 0)
+(declare-fun f ((-> U U)) U)
+(declare-fun g ((-> U U)) U)
+(declare-fun h ((-> U U)) U)
+(declare-fun a (U) U)
+(declare-fun b (U) U)
+(declare-fun c () U)
+(assert (distinct f g h))
+(assert (not (= (f a) (f b))))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic ALL)
+(set-info :status sat)
+(declare-sort U 0)
+(declare-fun f ((-> U U)) U)
+(declare-fun g ((-> U U)) U)
+(declare-fun h ((-> U U)) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(assert (distinct f g h))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic UF)
+(set-info :status sat)
+(declare-sort U 0)
+(declare-fun f (U U) U)
+(declare-fun g (U) U)
+(declare-fun h (U) U)
+(declare-fun i (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(assert (distinct (f a) g h))
+(assert (= i (f a)))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic UF)
+(set-info :status sat)
+(declare-sort U 0)
+(declare-fun f (U U) U)
+(declare-fun g (U) U)
+(declare-fun h (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+(assert (distinct (f a) g h))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+(declare-sort Nat$ 0)
+(declare-sort Complex$ 0)
+(declare-sort Nat_poly$ 0)
+(declare-sort Complex_poly$ 0)
+(declare-sort Complex_poly_poly$ 0)
+(declare-fun n$ () Nat$)
+(declare-fun q$ () Complex_poly$)
+(declare-fun r$ () Complex_poly$)
+(declare-fun dvd$ (Complex_poly$ Complex_poly$) Bool)
+(declare-fun one$ () Nat$)
+(declare-fun suc$ (Nat$) Nat$)
+(declare-fun dvd$a (Complex$ Complex$) Bool)
+(declare-fun dvd$b (Nat$ Nat$) Bool)
+(declare-fun dvd$c (Complex_poly_poly$ Complex_poly_poly$) Bool)
+(declare-fun dvd$d (Nat_poly$ Nat_poly$) Bool)
+(declare-fun one$a () Complex_poly$)
+(declare-fun one$b () Complex$)
+(declare-fun one$c () Nat_poly$)
+(declare-fun plus$ (Complex$ Complex$) Complex$)
+(declare-fun poly$ (Complex_poly$) (-> Complex$ Complex$))
+(declare-fun zero$ () Complex$)
+(declare-fun coeff$ (Complex_poly_poly$ Nat$) Complex_poly$)
+(declare-fun monom$ (Complex$ Nat$) Complex_poly$)
+(declare-fun order$ (Complex$ Complex_poly$) Nat$)
+(declare-fun pCons$ (Complex$ Complex_poly$) Complex_poly$)
+(declare-fun plus$a (Nat$ Nat$) Nat$)
+(declare-fun plus$b (Nat_poly$ Nat_poly$) Nat_poly$)
+(declare-fun plus$c (Complex_poly$ Complex_poly$) Complex_poly$)
+(declare-fun poly$a (Complex_poly_poly$ Complex_poly$) Complex_poly$)
+(declare-fun poly$b (Nat_poly$ Nat$) Nat$)
+(declare-fun power$ (Complex_poly$ Nat$) Complex_poly$)
+(declare-fun psize$ (Complex_poly$) Nat$)
+(declare-fun times$ (Nat$ Nat$) Nat$)
+(declare-fun zero$a () Nat$)
+(declare-fun zero$b () Complex_poly_poly$)
+(declare-fun zero$c () Complex_poly$)
+(declare-fun zero$d () Nat_poly$)
+(declare-fun coeff$a (Nat_poly$ Nat$) Nat$)
+(declare-fun coeff$b (Complex_poly$ Nat$) Complex$)
+(declare-fun degree$ (Complex_poly_poly$) Nat$)
+(declare-fun monom$a (Complex_poly$ Nat$) Complex_poly_poly$)
+(declare-fun monom$b (Nat$ Nat$) Nat_poly$)
+(declare-fun order$a (Complex_poly$ Complex_poly_poly$) Nat$)
+(declare-fun pCons$a (Complex_poly$ Complex_poly_poly$) Complex_poly_poly$)
+(declare-fun pCons$b (Nat$ Nat_poly$) Nat_poly$)
+(declare-fun power$a (Complex_poly_poly$ Nat$) Complex_poly_poly$)
+(declare-fun power$b (Nat_poly$ Nat$) Nat_poly$)
+(declare-fun power$c (Nat$ Nat$) Nat$)
+(declare-fun power$d (Complex$ Nat$) Complex$)
+(declare-fun degree$a (Nat_poly$) Nat$)
+(declare-fun degree$b (Complex_poly$) Nat$)
+(declare-fun is_zero$ (Complex_poly$) Bool)
+(declare-fun less_eq$ (Nat$ Nat$) Bool)
+(declare-fun of_bool$ (Bool) Complex$)
+(declare-fun constant$ ((-> Complex$ Complex$)) Bool)
+(declare-fun of_bool$a (Bool) Complex_poly$)
+(declare-fun of_bool$b (Bool) Nat$)
+(declare-fun pcompose$ (Complex_poly$ Complex_poly$) Complex_poly$)
+(declare-fun pcompose$a (Complex_poly_poly$ Complex_poly_poly$) Complex_poly_poly$)
+(declare-fun pcompose$b (Nat_poly$ Nat_poly$) Nat_poly$)
+(declare-fun poly_shift$ (Nat$ Complex_poly$) Complex_poly$)
+(declare-fun offset_poly$ (Complex_poly$ Complex$) Complex_poly$)
+(declare-fun poly_cutoff$ (Nat$ Complex_poly$) Complex_poly$)
+(declare-fun rsquarefree$ (Complex_poly$) Bool)
+(declare-fun offset_poly$a (Nat_poly$ Nat$) Nat_poly$)
+(declare-fun reflect_poly$ (Complex_poly$) Complex_poly$)
+(declare-fun reflect_poly$a (Complex_poly_poly$) Complex_poly_poly$)
+(declare-fun reflect_poly$b (Nat_poly$) Nat_poly$)
+(declare-fun synthetic_div$ (Complex_poly$ Complex$) Complex_poly$)
+(assert (! (not (= (poly$ (power$ q$ n$)) (poly$ r$))) :named a0))
+(assert (! (forall ((?v0 Complex$)) (= (poly$ (power$ q$ n$) ?v0) (poly$ r$ ?v0))) :named a1))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Nat$) (?v2 Complex_poly$)) (= (poly$a (power$a ?v0 ?v1) ?v2) (power$ (poly$a ?v0 ?v2) ?v1))) :named a2))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$) (?v2 Nat$)) (= (poly$b (power$b ?v0 ?v1) ?v2) (power$c (poly$b ?v0 ?v2) ?v1))) :named a3))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Complex$)) (= (poly$ (power$ ?v0 ?v1) ?v2) (power$d (poly$ ?v0 ?v2) ?v1))) :named a4))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= (poly$ ?v0) (poly$ ?v1)) (= ?v0 ?v1))) :named a5))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (not (constant$ (poly$ ?v0))) (exists ((?v1 Complex$)) (= (poly$ ?v0 ?v1) zero$)))) :named a6))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (reflect_poly$ (power$ ?v0 ?v1)) (power$ (reflect_poly$ ?v0) ?v1))) :named a7))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Nat$)) (= (coeff$ (power$a ?v0 ?v1) zero$a) (power$ (coeff$ ?v0 zero$a) ?v1))) :named a8))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$)) (= (coeff$a (power$b ?v0 ?v1) zero$a) (power$c (coeff$a ?v0 zero$a) ?v1))) :named a9))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (coeff$b (power$ ?v0 ?v1) zero$a) (power$d (coeff$b ?v0 zero$a) ?v1))) :named a10))
+(assert (! (forall ((?v0 (-> Complex$ Complex$))) (= (constant$ ?v0) (forall ((?v1 Complex$) (?v2 Complex$)) (= (?v0 ?v1) (?v0 ?v2))))) :named a11))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (exists ((?v2 Complex_poly$)) (and (= (psize$ ?v2) (psize$ ?v0)) (forall ((?v3 Complex$)) (= (poly$ ?v2 ?v3) (poly$ ?v0 (plus$ ?v1 ?v3))))))) :named a12))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$) (?v2 Complex$)) (= (poly$ (offset_poly$ ?v0 ?v1) ?v2) (poly$ ?v0 (plus$ ?v1 ?v2)))) :named a13))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$) (?v2 Nat$)) (= (poly$b (offset_poly$a ?v0 ?v1) ?v2) (poly$b ?v0 (plus$a ?v1 ?v2)))) :named a14))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex$)) (= (poly$ (pcompose$ ?v0 ?v1) ?v2) (poly$ ?v0 (poly$ ?v1 ?v2)))) :named a15))
+(assert (! (forall ((?v0 Complex_poly$)) (= (power$ ?v0 one$) ?v0)) :named a16))
+(assert (! (forall ((?v0 Nat$)) (= (power$c ?v0 one$) ?v0)) :named a17))
+(assert (! (forall ((?v0 Nat$)) (= (power$ one$a ?v0) one$a)) :named a18))
+(assert (! (forall ((?v0 Nat$)) (= (power$c one$ ?v0) one$)) :named a19))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Nat$)) (= (coeff$ (power$a ?v0 ?v1) (degree$ (power$a ?v0 ?v1))) (power$ (coeff$ ?v0 (degree$ ?v0)) ?v1))) :named a20))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$)) (= (coeff$a (power$b ?v0 ?v1) (degree$a (power$b ?v0 ?v1))) (power$c (coeff$a ?v0 (degree$a ?v0)) ?v1))) :named a21))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (coeff$b (power$ ?v0 ?v1) (degree$b (power$ ?v0 ?v1))) (power$d (coeff$b ?v0 (degree$b ?v0)) ?v1))) :named a22))
+(assert (! (forall ((?v0 Nat$)) (= (coeff$ zero$b ?v0) zero$c)) :named a23))
+(assert (! (forall ((?v0 Nat$)) (= (coeff$a zero$d ?v0) zero$a)) :named a24))
+(assert (! (forall ((?v0 Nat$)) (= (coeff$b zero$c ?v0) zero$)) :named a25))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat_poly$) (?v2 Nat$)) (= (coeff$a (plus$b ?v0 ?v1) ?v2) (plus$a (coeff$a ?v0 ?v2) (coeff$a ?v1 ?v2)))) :named a26))
+(assert (! (forall ((?v0 Complex_poly$)) (= (poly$a zero$b ?v0) zero$c)) :named a27))
+(assert (! (forall ((?v0 Nat$)) (= (poly$b zero$d ?v0) zero$a)) :named a28))
+(assert (! (forall ((?v0 Complex$)) (= (poly$ zero$c ?v0) zero$)) :named a29))
+(assert (! (= (degree$b one$a) zero$a) :named a30))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex$)) (= (poly$ (plus$c ?v0 ?v1) ?v2) (plus$ (poly$ ?v0 ?v2) (poly$ ?v1 ?v2)))) :named a31))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat_poly$) (?v2 Nat$)) (= (poly$b (plus$b ?v0 ?v1) ?v2) (plus$a (poly$b ?v0 ?v2) (poly$b ?v1 ?v2)))) :named a32))
+(assert (! (forall ((?v0 Complex$)) (= (poly$ one$a ?v0) one$b)) :named a33))
+(assert (! (forall ((?v0 Nat$)) (= (poly$b one$c ?v0) one$)) :named a34))
+(assert (! (forall ((?v0 Complex_poly$)) (= (= (coeff$b ?v0 (degree$b ?v0)) zero$) (= ?v0 zero$c))) :named a35))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (= (coeff$ ?v0 (degree$ ?v0)) zero$c) (= ?v0 zero$b))) :named a36))
+(assert (! (forall ((?v0 Nat_poly$)) (= (= (coeff$a ?v0 (degree$a ?v0)) zero$a) (= ?v0 zero$d))) :named a37))
+(assert (! (= (coeff$b one$a (degree$b one$a)) one$b) :named a38))
+(assert (! (= (coeff$a one$c (degree$a one$c)) one$) :named a39))
+(assert (! (forall ((?v0 Complex_poly$)) (= (= (poly$ (reflect_poly$ ?v0) zero$) zero$) (= ?v0 zero$c))) :named a40))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (= (poly$a (reflect_poly$a ?v0) zero$c) zero$c) (= ?v0 zero$b))) :named a41))
+(assert (! (forall ((?v0 Nat_poly$)) (= (= (poly$b (reflect_poly$b ?v0) zero$a) zero$a) (= ?v0 zero$d))) :named a42))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= (coeff$b ?v0 zero$a) zero$)) (= (reflect_poly$ (reflect_poly$ ?v0)) ?v0))) :named a43))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (=> (not (= (coeff$ ?v0 zero$a) zero$c)) (= (reflect_poly$a (reflect_poly$a ?v0)) ?v0))) :named a44))
+(assert (! (forall ((?v0 Nat_poly$)) (=> (not (= (coeff$a ?v0 zero$a) zero$a)) (= (reflect_poly$b (reflect_poly$b ?v0)) ?v0))) :named a45))
+(assert (! (forall ((?v0 Complex_poly$)) (= (= (coeff$b (reflect_poly$ ?v0) zero$a) zero$) (= ?v0 zero$c))) :named a46))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (= (coeff$ (reflect_poly$a ?v0) zero$a) zero$c) (= ?v0 zero$b))) :named a47))
+(assert (! (forall ((?v0 Nat_poly$)) (= (= (coeff$a (reflect_poly$b ?v0) zero$a) zero$a) (= ?v0 zero$d))) :named a48))
+(assert (! (forall ((?v0 Complex_poly$)) (= (coeff$b (reflect_poly$ ?v0) zero$a) (coeff$b ?v0 (degree$b ?v0)))) :named a49))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= (coeff$b ?v0 zero$a) zero$)) (= (degree$b (reflect_poly$ ?v0)) (degree$b ?v0)))) :named a50))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (=> (not (= (coeff$ ?v0 zero$a) zero$c)) (= (degree$ (reflect_poly$a ?v0)) (degree$ ?v0)))) :named a51))
+(assert (! (forall ((?v0 Nat_poly$)) (=> (not (= (coeff$a ?v0 zero$a) zero$a)) (= (degree$a (reflect_poly$b ?v0)) (degree$a ?v0)))) :named a52))
+(assert (! (forall ((?v0 Complex_poly$)) (= (poly$ (reflect_poly$ ?v0) zero$) (coeff$b ?v0 (degree$b ?v0)))) :named a53))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (poly$a (reflect_poly$a ?v0) zero$c) (coeff$ ?v0 (degree$ ?v0)))) :named a54))
+(assert (! (forall ((?v0 Nat_poly$)) (= (poly$b (reflect_poly$b ?v0) zero$a) (coeff$a ?v0 (degree$a ?v0)))) :named a55))
+(assert (! (forall ((?v0 Complex_poly$)) (= (poly$ ?v0 zero$) (coeff$b ?v0 zero$a))) :named a56))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (poly$a ?v0 zero$c) (coeff$ ?v0 zero$a))) :named a57))
+(assert (! (forall ((?v0 Nat_poly$)) (= (poly$b ?v0 zero$a) (coeff$a ?v0 zero$a))) :named a58))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat_poly$) (?v2 Nat$)) (= (coeff$a (plus$b ?v0 ?v1) ?v2) (plus$a (coeff$a ?v0 ?v2) (coeff$a ?v1 ?v2)))) :named a59))
+(assert (! (forall ((?v0 Complex_poly$)) (= (forall ((?v1 Complex$)) (= (poly$ ?v0 ?v1) zero$)) (= ?v0 zero$c))) :named a60))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (forall ((?v1 Complex_poly$)) (= (poly$a ?v0 ?v1) zero$c)) (= ?v0 zero$b))) :named a61))
+(assert (! (forall ((?v0 Nat$)) (= (coeff$ zero$b ?v0) zero$c)) :named a62))
+(assert (! (forall ((?v0 Nat$)) (= (coeff$a zero$d ?v0) zero$a)) :named a63))
+(assert (! (forall ((?v0 Nat$)) (= (coeff$b zero$c ?v0) zero$)) :named a64))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (=> (not (= ?v0 zero$b)) (not (= (coeff$ ?v0 (degree$ ?v0)) zero$c)))) :named a65))
+(assert (! (forall ((?v0 Nat_poly$)) (=> (not (= ?v0 zero$d)) (not (= (coeff$a ?v0 (degree$a ?v0)) zero$a)))) :named a66))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= ?v0 zero$c)) (not (= (coeff$b ?v0 (degree$b ?v0)) zero$)))) :named a67))
+(assert (! (forall ((?v0 Complex_poly$)) (! (= (power$ ?v0 zero$a) one$a) :pattern ((power$ ?v0)))) :named a68))
+(assert (! (forall ((?v0 Nat$)) (! (= (power$c ?v0 zero$a) one$) :pattern ((power$c ?v0)))) :named a69))
+(assert (! (forall ((?v0 Nat$)) (= (power$d zero$ ?v0) (ite (= ?v0 zero$a) one$b zero$))) :named a70))
+(assert (! (forall ((?v0 Nat$)) (= (power$ zero$c ?v0) (ite (= ?v0 zero$a) one$a zero$c))) :named a71))
+(assert (! (forall ((?v0 Nat$)) (= (power$c zero$a ?v0) (ite (= ?v0 zero$a) one$ zero$a))) :named a72))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (degree$b (offset_poly$ ?v0 ?v1)) (degree$b ?v0))) :named a73))
+(assert (! (forall ((?v0 Complex_poly$)) (= (constant$ (poly$ ?v0)) (= (degree$b ?v0) zero$a))) :named a74))
+(assert (! (forall ((?v0 Complex$)) (= zero$ (poly$ zero$c ?v0))) :named a75))
+(assert (! (forall ((?v0 Complex_poly$)) (= zero$c (poly$a zero$b ?v0))) :named a76))
+(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex$)) (and (= (poly$ ?v0 ?v1) zero$) (not (= (poly$ zero$c ?v1) zero$)))) false)) :named a77))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (exists ((?v1 Complex_poly$)) (and (= (poly$a ?v0 ?v1) zero$c) (not (= (poly$a zero$b ?v1) zero$c)))) false)) :named a78))
+(assert (! (forall ((?v0 Nat_poly$)) (= (exists ((?v1 Nat$)) (and (= (poly$b ?v0 ?v1) zero$a) (not (= (poly$b zero$d ?v1) zero$a)))) false)) :named a79))
+(assert (! (= (exists ((?v0 Complex_poly$)) (not (= (poly$a zero$b ?v0) zero$c))) false) :named a80))
+(assert (! (= (exists ((?v0 Nat$)) (not (= (poly$b zero$d ?v0) zero$a))) false) :named a81))
+(assert (! (= (exists ((?v0 Complex$)) (not (= (poly$ zero$c ?v0) zero$))) false) :named a82))
+(assert (! (= (exists ((?v0 Complex_poly$)) (= (poly$a zero$b ?v0) zero$c)) true) :named a83))
+(assert (! (= (exists ((?v0 Nat$)) (= (poly$b zero$d ?v0) zero$a)) true) :named a84))
+(assert (! (= (exists ((?v0 Complex$)) (= (poly$ zero$c ?v0) zero$)) true) :named a85))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (=> (not (= ?v0 zero$)) (not (= (power$d ?v0 ?v1) zero$)))) :named a86))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (=> (not (= ?v0 zero$c)) (not (= (power$ ?v0 ?v1) zero$c)))) :named a87))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (not (= ?v0 zero$a)) (not (= (power$c ?v0 ?v1) zero$a)))) :named a88))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a89))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a90))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a91))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ ?v0 zero$) ?v0)) :named a92))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c ?v0 zero$c) ?v0)) :named a93))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a94))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= (plus$ ?v0 ?v1) ?v1) (= ?v0 zero$))) :named a95))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= (plus$c ?v0 ?v1) ?v1) (= ?v0 zero$c))) :named a96))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) ?v1) (= ?v0 zero$a))) :named a97))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= (plus$ ?v0 ?v1) ?v0) (= ?v1 zero$))) :named a98))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= (plus$c ?v0 ?v1) ?v0) (= ?v1 zero$c))) :named a99))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) ?v0) (= ?v1 zero$a))) :named a100))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= ?v0 (plus$ ?v1 ?v0)) (= ?v1 zero$))) :named a101))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= ?v0 (plus$c ?v1 ?v0)) (= ?v1 zero$c))) :named a102))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= ?v0 (plus$a ?v1 ?v0)) (= ?v1 zero$a))) :named a103))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= ?v0 (plus$ ?v0 ?v1)) (= ?v1 zero$))) :named a104))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= ?v0 (plus$c ?v0 ?v1)) (= ?v1 zero$c))) :named a105))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= ?v0 (plus$a ?v0 ?v1)) (= ?v1 zero$a))) :named a106))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) zero$a) (and (= ?v0 zero$a) (= ?v1 zero$a)))) :named a107))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= zero$a (plus$a ?v0 ?v1)) (and (= ?v0 zero$a) (= ?v1 zero$a)))) :named a108))
+(assert (! (forall ((?v0 Complex_poly$)) (! (= (power$ ?v0 zero$a) one$a) :pattern ((power$ ?v0)))) :named a109))
+(assert (! (forall ((?v0 Nat$)) (! (= (power$c ?v0 zero$a) one$) :pattern ((power$c ?v0)))) :named a110))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v2 ?v1)) (= ?v0 ?v2))) :named a111))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (= ?v1 ?v2))) :named a112))
+(assert (! (forall ((?v0 Complex_poly$)) (= (pcompose$ zero$c ?v0) zero$c)) :named a113))
+(assert (! (= (reflect_poly$ zero$c) zero$c) :named a114))
+(assert (! (= (degree$b zero$c) zero$a) :named a115))
+(assert (! (forall ((?v0 Complex_poly$)) (= (= (psize$ ?v0) zero$a) (= ?v0 zero$c))) :named a116))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (= (offset_poly$ ?v0 ?v1) zero$c) (= ?v0 zero$c))) :named a117))
+(assert (! (forall ((?v0 Complex$)) (= (offset_poly$ zero$c ?v0) zero$c)) :named a118))
+(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex$)) (not (= (poly$ ?v0 ?v1) zero$))) (not (= ?v0 zero$c)))) :named a119))
+(assert (! (forall ((?v0 Complex$)) (= (= zero$ ?v0) (= ?v0 zero$))) :named a120))
+(assert (! (forall ((?v0 Complex_poly$)) (= (= zero$c ?v0) (= ?v0 zero$c))) :named a121))
+(assert (! (forall ((?v0 Nat$)) (= (= zero$a ?v0) (= ?v0 zero$a))) :named a122))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (= (plus$a ?v0 ?v1) (plus$a ?v2 ?v1)) (= ?v0 ?v2))) :named a123))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (= (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (= ?v1 ?v2))) :named a124))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a ?v0 (plus$a ?v1 ?v2)) (plus$a ?v1 (plus$a ?v0 ?v2)))) :named a125))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (plus$a ?v0 ?v1) (plus$a ?v1 ?v0))) :named a126))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a ?v0 (plus$a ?v1 ?v2)))) :named a127))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$) (?v3 Nat$)) (= (plus$a (plus$a ?v0 ?v1) (plus$a ?v2 ?v3)) (plus$a (plus$a ?v0 ?v2) (plus$a ?v1 ?v3)))) :named a128))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a ?v0 (plus$a ?v1 ?v2)))) :named a129))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a ?v0 (plus$a ?v1 ?v2)) (plus$a ?v1 (plus$a ?v0 ?v2)))) :named a130))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a (plus$a ?v0 ?v2) ?v1))) :named a131))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (plus$a ?v0 ?v1) (plus$a ?v1 ?v0))) :named a132))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a ?v0 (plus$a ?v1 ?v2)) (plus$a (plus$a ?v0 ?v1) ?v2))) :named a133))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$) (?v3 Nat$)) (=> (and (= ?v0 ?v1) (= ?v2 ?v3)) (= (plus$a ?v0 ?v2) (plus$a ?v1 ?v3)))) :named a134))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$a (plus$a ?v0 ?v1) ?v2) (plus$a ?v0 (plus$a ?v1 ?v2)))) :named a135))
+(assert (! (forall ((?v0 Nat$)) (= (= one$ ?v0) (= ?v0 one$))) :named a136))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (= ?v0 (plus$ ?v0 ?v1)) (= ?v1 zero$))) :named a137))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (= ?v0 (plus$c ?v0 ?v1)) (= ?v1 zero$c))) :named a138))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= ?v0 (plus$a ?v0 ?v1)) (= ?v1 zero$a))) :named a139))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a140))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a141))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ ?v0 zero$) ?v0)) :named a142))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c ?v0 zero$c) ?v0)) :named a143))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a144))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a145))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a146))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a147))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ zero$ ?v0) ?v0)) :named a148))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c zero$c ?v0) ?v0)) :named a149))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a150))
+(assert (! (forall ((?v0 Complex$)) (= (plus$ ?v0 zero$) ?v0)) :named a151))
+(assert (! (forall ((?v0 Complex_poly$)) (= (plus$c ?v0 zero$c) ?v0)) :named a152))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a153))
+(assert (! (forall ((?v0 Complex_poly$)) (= (power$ ?v0 one$) ?v0)) :named a154))
+(assert (! (forall ((?v0 Nat$)) (= (power$c ?v0 one$) ?v0)) :named a155))
+(assert (! (forall ((?v0 Nat$)) (= (poly_cutoff$ ?v0 one$a) (ite (= ?v0 zero$a) zero$c one$a))) :named a156))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a ?v0 zero$a) ?v0)) :named a157))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (plus$a ?v0 ?v1) zero$a) (and (= ?v0 zero$a) (= ?v1 zero$a)))) :named a158))
+(assert (! (forall ((?v0 Nat$)) (= (poly_shift$ ?v0 one$a) (ite (= ?v0 zero$a) one$a zero$c))) :named a159))
+(assert (! (not (= zero$ one$b)) :named a160))
+(assert (! (not (= zero$c one$a)) :named a161))
+(assert (! (not (= zero$a one$)) :named a162))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (= (synthetic_div$ ?v0 ?v1) zero$c) (= (degree$b ?v0) zero$a))) :named a163))
+(assert (! (= (of_bool$ false) zero$) :named a164))
+(assert (! (= (of_bool$a false) zero$c) :named a165))
+(assert (! (= (of_bool$b false) zero$a) :named a166))
+(assert (! (= (of_bool$b true) one$) :named a167))
+(assert (! (forall ((?v0 Complex$)) (= (synthetic_div$ zero$c ?v0) zero$c)) :named a168))
+(assert (! (forall ((?v0 Nat$)) (= (poly_shift$ ?v0 zero$c) zero$c)) :named a169))
+(assert (! (forall ((?v0 Nat$)) (= (poly_cutoff$ ?v0 zero$c) zero$c)) :named a170))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (= ?v1 ?v2))) :named a171))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (plus$a ?v0 ?v1) (plus$a ?v2 ?v1)) (= ?v0 ?v2))) :named a172))
+(assert (! (forall ((?v0 Bool)) (! (= (of_bool$ ?v0) (ite ?v0 one$b zero$)) :pattern ((of_bool$ ?v0)))) :named a173))
+(assert (! (forall ((?v0 Bool)) (! (= (of_bool$a ?v0) (ite ?v0 one$a zero$c)) :pattern ((of_bool$a ?v0)))) :named a174))
+(assert (! (forall ((?v0 Bool)) (! (= (of_bool$b ?v0) (ite ?v0 one$ zero$a)) :pattern ((of_bool$b ?v0)))) :named a175))
+(assert (! (forall ((?v0 (-> Complex$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$ ?v1)) (and (=> ?v1 (?v0 one$b)) (=> (not ?v1) (?v0 zero$))))) :named a176))
+(assert (! (forall ((?v0 (-> Complex_poly$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$a ?v1)) (and (=> ?v1 (?v0 one$a)) (=> (not ?v1) (?v0 zero$c))))) :named a177))
+(assert (! (forall ((?v0 (-> Nat$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$b ?v1)) (and (=> ?v1 (?v0 one$)) (=> (not ?v1) (?v0 zero$a))))) :named a178))
+(assert (! (forall ((?v0 (-> Complex$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$ ?v1)) (not (or (and ?v1 (not (?v0 one$b))) (and (not ?v1) (not (?v0 zero$))))))) :named a179))
+(assert (! (forall ((?v0 (-> Complex_poly$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$a ?v1)) (not (or (and ?v1 (not (?v0 one$a))) (and (not ?v1) (not (?v0 zero$c))))))) :named a180))
+(assert (! (forall ((?v0 (-> Nat$ Bool)) (?v1 Bool)) (= (?v0 (of_bool$b ?v1)) (not (or (and ?v1 (not (?v0 one$))) (and (not ?v1) (not (?v0 zero$a))))))) :named a181))
+(assert (! (forall ((?v0 Nat$)) (= (plus$a zero$a ?v0) ?v0)) :named a182))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (= (plus$a ?v0 ?v1) ?v0) (= ?v1 zero$a))) :named a183))
+(assert (! (forall ((?v0 Nat$)) (=> (and (=> (= ?v0 zero$a) false) (=> (not (= ?v0 zero$a)) false)) false)) :named a184))
+(assert (! (forall ((?v0 (-> Nat$ (-> Nat$ Bool))) (?v1 Nat$) (?v2 Nat$)) (=> (and (forall ((?v3 Nat$) (?v4 Nat$)) (= (?v0 ?v3 ?v4) (?v0 ?v4 ?v3))) (and (forall ((?v3 Nat$)) (?v0 ?v3 zero$a)) (forall ((?v3 Nat$) (?v4 Nat$)) (=> (?v0 ?v3 ?v4) (?v0 ?v3 (plus$a ?v3 ?v4)))))) (?v0 ?v1 ?v2))) :named a185))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (forall ((?v2 Complex$)) (=> (= (poly$ ?v0 ?v2) zero$) (= (poly$ ?v1 ?v2) zero$))) (or (dvd$ ?v0 (power$ ?v1 (degree$b ?v0))) (and (= ?v0 zero$c) (= ?v1 zero$c))))) :named a186))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Nat$)) (=> (and (forall ((?v3 Complex$)) (=> (= (poly$ ?v0 ?v3) zero$) (= (poly$ ?v1 ?v3) zero$))) (and (= (degree$b ?v0) ?v2) (not (= ?v2 zero$a)))) (dvd$ ?v0 (power$ ?v1 ?v2)))) :named a187))
+(assert (! (forall ((?v0 Complex_poly$)) (! (= (is_zero$ ?v0) (= ?v0 zero$c)) :pattern ((is_zero$ ?v0)))) :named a188))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (= (= (poly$ ?v0 ?v1) zero$) (or (= ?v0 zero$c) (not (= (order$ ?v1 ?v0) zero$a))))) :named a189))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly$)) (= (= (poly$a ?v0 ?v1) zero$c) (or (= ?v0 zero$b) (not (= (order$a ?v1 ?v0) zero$a))))) :named a190))
+(assert (! (forall ((?v0 Complex$)) (dvd$a ?v0 zero$)) :named a191))
+(assert (! (forall ((?v0 Complex_poly$)) (dvd$ ?v0 zero$c)) :named a192))
+(assert (! (forall ((?v0 Nat$)) (dvd$b ?v0 zero$a)) :named a193))
+(assert (! (forall ((?v0 Complex$)) (= (dvd$a zero$ ?v0) (= ?v0 zero$))) :named a194))
+(assert (! (forall ((?v0 Complex_poly$)) (= (dvd$ zero$c ?v0) (= ?v0 zero$c))) :named a195))
+(assert (! (forall ((?v0 Nat$)) (= (dvd$b zero$a ?v0) (= ?v0 zero$a))) :named a196))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (dvd$ ?v0 (plus$c ?v0 ?v1)) (dvd$ ?v0 ?v1))) :named a197))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$b ?v0 (plus$a ?v0 ?v1)) (dvd$b ?v0 ?v1))) :named a198))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (dvd$ ?v0 (plus$c ?v1 ?v0)) (dvd$ ?v0 ?v1))) :named a199))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$b ?v0 (plus$a ?v1 ?v0)) (dvd$b ?v0 ?v1))) :named a200))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (not (= ?v0 zero$a)) (= (dvd$b (power$c ?v1 ?v0) (power$c ?v2 ?v0)) (dvd$b ?v1 ?v2)))) :named a201))
+(assert (! (forall ((?v0 Complex$)) (=> (dvd$a zero$ ?v0) (= ?v0 zero$))) :named a202))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (dvd$ zero$c ?v0) (= ?v0 zero$c))) :named a203))
+(assert (! (forall ((?v0 Nat$)) (=> (dvd$b zero$a ?v0) (= ?v0 zero$a))) :named a204))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (dvd$ ?v0 ?v1) (= (dvd$ ?v0 (plus$c ?v1 ?v2)) (dvd$ ?v0 ?v2)))) :named a205))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (dvd$b ?v0 ?v1) (= (dvd$b ?v0 (plus$a ?v1 ?v2)) (dvd$b ?v0 ?v2)))) :named a206))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (dvd$ ?v0 ?v1) (= (dvd$ ?v0 (plus$c ?v2 ?v1)) (dvd$ ?v0 ?v2)))) :named a207))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (dvd$b ?v0 ?v1) (= (dvd$b ?v0 (plus$a ?v2 ?v1)) (dvd$b ?v0 ?v2)))) :named a208))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (and (dvd$ ?v0 ?v1) (dvd$ ?v0 ?v2)) (dvd$ ?v0 (plus$c ?v1 ?v2)))) :named a209))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (and (dvd$b ?v0 ?v1) (dvd$b ?v0 ?v2)) (dvd$b ?v0 (plus$a ?v1 ?v2)))) :named a210))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (=> (and (dvd$ ?v0 ?v1) (dvd$ ?v1 one$a)) (dvd$ ?v0 one$a))) :named a211))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (and (dvd$b ?v0 ?v1) (dvd$b ?v1 one$)) (dvd$b ?v0 one$))) :named a212))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (=> (dvd$ ?v0 one$a) (dvd$ ?v0 ?v1))) :named a213))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (dvd$b ?v0 one$) (dvd$b ?v0 ?v1))) :named a214))
+(assert (! (forall ((?v0 Complex_poly$)) (dvd$ one$a ?v0)) :named a215))
+(assert (! (forall ((?v0 Nat$)) (dvd$b one$ ?v0)) :named a216))
+(assert (! (forall ((?v0 Complex_poly$)) (dvd$ ?v0 ?v0)) :named a217))
+(assert (! (forall ((?v0 Nat$)) (dvd$b ?v0 ?v0)) :named a218))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (and (dvd$ ?v0 ?v1) (dvd$ ?v1 ?v2)) (dvd$ ?v0 ?v2))) :named a219))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (and (dvd$b ?v0 ?v1) (dvd$b ?v1 ?v2)) (dvd$b ?v0 ?v2))) :named a220))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$) (?v2 Nat$)) (=> (dvd$ ?v0 ?v1) (dvd$ (power$ ?v0 ?v2) (power$ ?v1 ?v2)))) :named a221))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (dvd$b ?v0 ?v1) (dvd$b (power$c ?v0 ?v2) (power$c ?v1 ?v2)))) :named a222))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (=> (and (dvd$b (power$c ?v0 ?v1) (power$c ?v2 ?v1)) (not (= ?v1 zero$a))) (dvd$b ?v0 ?v2))) :named a223))
+(assert (! (not (dvd$ zero$c one$a)) :named a224))
+(assert (! (not (dvd$b zero$a one$)) :named a225))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (dvd$ (power$ ?v0 ?v1) one$a) (or (dvd$ ?v0 one$a) (= ?v1 zero$a)))) :named a226))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$b (power$c ?v0 ?v1) one$) (or (dvd$b ?v0 one$) (= ?v1 zero$a)))) :named a227))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (! (=> (not (= (poly$ ?v0 ?v1) zero$)) (= (order$ ?v1 ?v0) zero$a)) :pattern ((order$ ?v1 ?v0)))) :named a228))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly$)) (! (=> (not (= (poly$a ?v0 ?v1) zero$c)) (= (order$a ?v1 ?v0) zero$a)) :pattern ((order$a ?v1 ?v0)))) :named a229))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (not (= ?v0 zero$c)) (= (dvd$ ?v0 one$a) (= (degree$b ?v0) zero$a)))) :named a230))
+(assert (! (forall ((?v0 Complex_poly$)) (= (rsquarefree$ ?v0) (and (not (= ?v0 zero$c)) (forall ((?v1 Complex$)) (or (= (order$ ?v1 ?v0) zero$a) (= (order$ ?v1 ?v0) one$)))))) :named a231))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$) (?v2 Complex_poly$)) (=> (not (= ?v0 zero$c)) (= (exists ((?v3 Complex$)) (and (= (poly$ (pCons$ ?v1 ?v0) ?v3) zero$) (not (= (poly$ ?v2 ?v3) zero$)))) (not (dvd$ (pCons$ ?v1 ?v0) (power$ ?v2 (psize$ ?v0))))))) :named a232))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (! (= (dvd$a ?v0 ?v1) (=> (= ?v0 zero$) (= ?v1 zero$))) :pattern ((dvd$a ?v0 ?v1)))) :named a233))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (dvd$ ?v0 one$a) (= (monom$ (coeff$b ?v0 (degree$b ?v0)) zero$a) ?v0))) :named a234))
+(assert (! (forall ((?v0 Nat$)) (= (dvd$b ?v0 one$) (= ?v0 one$))) :named a235))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$) (?v2 Complex$) (?v3 Complex_poly$)) (= (= (pCons$ ?v0 ?v1) (pCons$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a236))
+(assert (! (= (pCons$ zero$ zero$c) zero$c) :named a237))
+(assert (! (= (pCons$a zero$c zero$b) zero$b) :named a238))
+(assert (! (= (pCons$b zero$a zero$d) zero$d) :named a239))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly_poly$)) (= (= (pCons$a ?v0 ?v1) zero$b) (and (= ?v0 zero$c) (= ?v1 zero$b)))) :named a240))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat_poly$)) (= (= (pCons$b ?v0 ?v1) zero$d) (and (= ?v0 zero$a) (= ?v1 zero$d)))) :named a241))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (= (pCons$ ?v0 ?v1) zero$c) (and (= ?v0 zero$) (= ?v1 zero$c)))) :named a242))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (coeff$b (pCons$ ?v0 ?v1) zero$a) ?v0)) :named a243))
+(assert (! (forall ((?v0 Nat$)) (= (monom$ zero$ ?v0) zero$c)) :named a244))
+(assert (! (forall ((?v0 Nat$)) (= (monom$a zero$c ?v0) zero$b)) :named a245))
+(assert (! (forall ((?v0 Nat$)) (= (monom$b zero$a ?v0) zero$d)) :named a246))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (= (= (monom$a ?v0 ?v1) zero$b) (= ?v0 zero$c))) :named a247))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (monom$b ?v0 ?v1) zero$d) (= ?v0 zero$a))) :named a248))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (= (monom$ ?v0 ?v1) zero$c) (= ?v0 zero$))) :named a249))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$b (monom$ ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$))) :named a250))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$ (monom$a ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$c))) :named a251))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$a (monom$b ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$a))) :named a252))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$) (?v2 Complex$) (?v3 Complex_poly$)) (= (plus$c (pCons$ ?v0 ?v1) (pCons$ ?v2 ?v3)) (pCons$ (plus$ ?v0 ?v2) (plus$c ?v1 ?v3)))) :named a253))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat_poly$) (?v2 Nat$) (?v3 Nat_poly$)) (= (plus$b (pCons$b ?v0 ?v1) (pCons$b ?v2 ?v3)) (pCons$b (plus$a ?v0 ?v2) (plus$b ?v1 ?v3)))) :named a254))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (coeff$b (monom$ ?v0 ?v1) (degree$b (monom$ ?v0 ?v1))) ?v0)) :named a255))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (=> (not (= ?v0 zero$)) (= (order$ zero$ (monom$ ?v0 ?v1)) ?v1))) :named a256))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (=> (not (= ?v0 zero$c)) (= (order$a zero$c (monom$a ?v0 ?v1)) ?v1))) :named a257))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (pcompose$ (pCons$ ?v0 zero$c) ?v1) (pCons$ ?v0 zero$c))) :named a258))
+(assert (! (forall ((?v0 Complex$)) (= (reflect_poly$ (pCons$ ?v0 zero$c)) (pCons$ ?v0 zero$c))) :named a259))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$) (?v2 Complex$)) (= (synthetic_div$ (pCons$ ?v0 ?v1) ?v2) (pCons$ (poly$ ?v1 ?v2) (synthetic_div$ ?v1 ?v2)))) :named a260))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (=> (= ?v0 zero$c) (= (coeff$b (pCons$ ?v1 ?v0) (degree$b (pCons$ ?v1 ?v0))) ?v1))) :named a261))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (=> (not (= ?v0 zero$c)) (= (coeff$b (pCons$ ?v1 ?v0) (degree$b (pCons$ ?v1 ?v0))) (coeff$b ?v0 (degree$b ?v0))))) :named a262))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (= (dvd$c (pCons$a ?v0 zero$b) (pCons$a ?v1 zero$b)) (dvd$ ?v0 ?v1))) :named a263))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (dvd$d (pCons$b ?v0 zero$d) (pCons$b ?v1 zero$d)) (dvd$b ?v0 ?v1))) :named a264))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (dvd$ (pCons$ ?v0 zero$c) (pCons$ ?v1 zero$c)) (dvd$a ?v0 ?v1))) :named a265))
+(assert (! (= (= (pCons$b one$ zero$d) one$c) true) :named a266))
+(assert (! (= (= (pCons$ one$b zero$c) one$a) true) :named a267))
+(assert (! (= (= one$c (pCons$b one$ zero$d)) true) :named a268))
+(assert (! (= (= one$a (pCons$ one$b zero$c)) true) :named a269))
+(assert (! (= (monom$b one$ zero$a) one$c) :named a270))
+(assert (! (forall ((?v0 Complex_poly$)) (= (pcompose$ ?v0 (pCons$ zero$ (pCons$ one$b zero$c))) ?v0)) :named a271))
+(assert (! (forall ((?v0 Complex_poly_poly$)) (= (pcompose$a ?v0 (pCons$a zero$c (pCons$a one$a zero$b))) ?v0)) :named a272))
+(assert (! (forall ((?v0 Nat_poly$)) (= (pcompose$b ?v0 (pCons$b zero$a (pCons$b one$ zero$d))) ?v0)) :named a273))
+(assert (! (forall ((?v0 Nat$)) (=> (dvd$b zero$a ?v0) (= ?v0 zero$a))) :named a274))
+(assert (! (forall ((?v0 Nat$)) (= (not (= ?v0 zero$a)) (and (dvd$b ?v0 zero$a) (not (= ?v0 zero$a))))) :named a275))
+(assert (! (forall ((?v0 Nat$)) (! (= (dvd$b zero$a ?v0) (= ?v0 zero$a)) :pattern ((dvd$b zero$a ?v0)))) :named a276))
+(assert (! (forall ((?v0 Nat$)) (not (and (dvd$b zero$a ?v0) (not (= zero$a ?v0))))) :named a277))
+(assert (! (forall ((?v0 Nat$)) (dvd$b ?v0 zero$a)) :named a278))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Complex_poly$)) (= (= (monom$a ?v0 ?v1) (pCons$a ?v2 zero$b)) (and (= ?v0 ?v2) (or (= ?v0 zero$c) (= ?v1 zero$a))))) :named a279))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (monom$b ?v0 ?v1) (pCons$b ?v2 zero$d)) (and (= ?v0 ?v2) (or (= ?v0 zero$a) (= ?v1 zero$a))))) :named a280))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Complex$)) (= (= (monom$ ?v0 ?v1) (pCons$ ?v2 zero$c)) (and (= ?v0 ?v2) (or (= ?v0 zero$) (= ?v1 zero$a))))) :named a281))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (forall ((?v1 Complex$) (?v2 Complex_poly$)) (=> (= ?v0 (pCons$ ?v1 ?v2)) false)) false)) :named a282))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (forall ((?v1 Complex$) (?v2 Complex_poly$)) (=> (= ?v0 (pCons$ ?v1 ?v2)) false)) false)) :named a283))
+(assert (! (forall ((?v0 (-> Complex_poly$ (-> Complex_poly$ Bool))) (?v1 Complex_poly$) (?v2 Complex_poly$)) (=> (and (?v0 zero$c zero$c) (forall ((?v3 Complex$) (?v4 Complex_poly$) (?v5 Complex$) (?v6 Complex_poly$)) (=> (?v0 ?v4 ?v6) (?v0 (pCons$ ?v3 ?v4) (pCons$ ?v5 ?v6))))) (?v0 ?v1 ?v2))) :named a284))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Complex$) (?v3 Nat$)) (= (= (monom$ ?v0 ?v1) (monom$ ?v2 ?v3)) (and (= ?v0 ?v2) (or (= ?v0 zero$) (= ?v1 ?v3))))) :named a285))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Complex_poly$) (?v3 Nat$)) (= (= (monom$a ?v0 ?v1) (monom$a ?v2 ?v3)) (and (= ?v0 ?v2) (or (= ?v0 zero$c) (= ?v1 ?v3))))) :named a286))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$) (?v3 Nat$)) (= (= (monom$b ?v0 ?v1) (monom$b ?v2 ?v3)) (and (= ?v0 ?v2) (or (= ?v0 zero$a) (= ?v1 ?v3))))) :named a287))
+(assert (! (forall ((?v0 Complex$)) (! (= (monom$ ?v0 zero$a) (pCons$ ?v0 zero$c)) :pattern ((monom$ ?v0)))) :named a288))
+(assert (! (forall ((?v0 (-> Complex_poly_poly$ Bool)) (?v1 Complex_poly_poly$)) (=> (and (?v0 zero$b) (forall ((?v2 Complex_poly$) (?v3 Complex_poly_poly$)) (=> (and (or (not (= ?v2 zero$c)) (not (= ?v3 zero$b))) (?v0 ?v3)) (?v0 (pCons$a ?v2 ?v3))))) (?v0 ?v1))) :named a289))
+(assert (! (forall ((?v0 (-> Nat_poly$ Bool)) (?v1 Nat_poly$)) (=> (and (?v0 zero$d) (forall ((?v2 Nat$) (?v3 Nat_poly$)) (=> (and (or (not (= ?v2 zero$a)) (not (= ?v3 zero$d))) (?v0 ?v3)) (?v0 (pCons$b ?v2 ?v3))))) (?v0 ?v1))) :named a290))
+(assert (! (forall ((?v0 (-> Complex_poly$ Bool)) (?v1 Complex_poly$)) (=> (and (?v0 zero$c) (forall ((?v2 Complex$) (?v3 Complex_poly$)) (=> (and (or (not (= ?v2 zero$)) (not (= ?v3 zero$c))) (?v0 ?v3)) (?v0 (pCons$ ?v2 ?v3))))) (?v0 ?v1))) :named a291))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$)) (=> (= (poly$ ?v0 ?v1) zero$) (= (poly$ (pCons$ zero$ ?v0) ?v1) zero$))) :named a292))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly$)) (=> (= (poly$a ?v0 ?v1) zero$c) (= (poly$a (pCons$a zero$c ?v0) ?v1) zero$c))) :named a293))
+(assert (! (forall ((?v0 Nat_poly$) (?v1 Nat$)) (=> (= (poly$b ?v0 ?v1) zero$a) (= (poly$b (pCons$b zero$a ?v0) ?v1) zero$a))) :named a294))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (=> (not (= ?v0 zero$)) (= (degree$b (monom$ ?v0 ?v1)) ?v1))) :named a295))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$)) (=> (not (= ?v0 zero$c)) (= (degree$ (monom$a ?v0 ?v1)) ?v1))) :named a296))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (=> (not (= ?v0 zero$a)) (= (degree$a (monom$b ?v0 ?v1)) ?v1))) :named a297))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$b (monom$ ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$))) :named a298))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$ (monom$a ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$c))) :named a299))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (coeff$a (monom$b ?v0 ?v1) ?v2) (ite (= ?v1 ?v2) ?v0 zero$a))) :named a300))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly$)) (=> (dvd$ ?v0 ?v1) (dvd$ ?v0 (pCons$ zero$ ?v1)))) :named a301))
+(assert (! (forall ((?v0 Complex_poly_poly$) (?v1 Complex_poly_poly$)) (=> (dvd$c ?v0 ?v1) (dvd$c ?v0 (pCons$a zero$c ?v1)))) :named a302))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (poly$ (pCons$ (poly$ zero$c ?v0) zero$c) ?v1) (poly$ zero$c ?v1))) :named a303))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= ?v0 (poly$ (pCons$ ?v0 zero$c) ?v1))) :named a304))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (plus$b (monom$b ?v0 ?v1) (monom$b ?v2 ?v1)) (monom$b (plus$a ?v0 ?v2) ?v1))) :named a305))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex$)) (= (offset_poly$ (pCons$ ?v0 zero$c) ?v1) (pCons$ ?v0 zero$c))) :named a306))
+(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex_poly$)) (= (poly$a (pCons$a ?v0 zero$b) ?v1) zero$c)) (= ?v0 zero$c))) :named a307))
+(assert (! (forall ((?v0 Nat$)) (= (exists ((?v1 Nat$)) (= (poly$b (pCons$b ?v0 zero$d) ?v1) zero$a)) (= ?v0 zero$a))) :named a308))
+(assert (! (forall ((?v0 Complex$)) (= (exists ((?v1 Complex$)) (= (poly$ (pCons$ ?v0 zero$c) ?v1) zero$)) (= ?v0 zero$))) :named a309))
+(assert (! (forall ((?v0 Complex_poly$)) (= (exists ((?v1 Complex_poly$)) (not (= (poly$a (pCons$a ?v0 zero$b) ?v1) zero$c))) (not (= ?v0 zero$c)))) :named a310))
+(assert (! (forall ((?v0 Nat$)) (= (exists ((?v1 Nat$)) (not (= (poly$b (pCons$b ?v0 zero$d) ?v1) zero$a))) (not (= ?v0 zero$a)))) :named a311))
+(assert (! (forall ((?v0 Complex$)) (= (exists ((?v1 Complex$)) (not (= (poly$ (pCons$ ?v0 zero$c) ?v1) zero$))) (not (= ?v0 zero$)))) :named a312))
+(assert (! (forall ((?v0 Complex$)) (= (poly$ (pCons$ zero$ zero$c) ?v0) (poly$ zero$c ?v0))) :named a313))
+(assert (! (forall ((?v0 Complex_poly$)) (= (poly$a (pCons$a zero$c zero$b) ?v0) (poly$a zero$b ?v0))) :named a314))
+(assert (! (forall ((?v0 Complex$)) (= (degree$b (pCons$ ?v0 zero$c)) zero$a)) :named a315))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (and (= (degree$b ?v0) zero$a) (forall ((?v1 Complex$)) (=> (= ?v0 (pCons$ ?v1 zero$c)) false))) false)) :named a316))
+(assert (! (= (pCons$b one$ zero$d) one$c) :named a317))
+(assert (! (= (pCons$ one$b zero$c) one$a) :named a318))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (monom$b ?v0 ?v1) one$c) (and (= ?v0 one$) (= ?v1 zero$a)))) :named a319))
+(assert (! (forall ((?v0 Complex$)) (= ?v0 (poly$ (pCons$ zero$ (pCons$ one$b zero$c)) ?v0))) :named a320))
+(assert (! (forall ((?v0 Complex_poly$)) (= ?v0 (poly$a (pCons$a zero$c (pCons$a one$a zero$b)) ?v0))) :named a321))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (not (exists ((?v1 Complex$) (?v2 Complex_poly$)) (and (not (= ?v1 zero$)) (and (= ?v2 zero$c) (= ?v0 (pCons$ ?v1 ?v2)))))) (exists ((?v1 Complex$)) (= (poly$ ?v0 ?v1) zero$)))) :named a322))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex$) (?v2 Complex$)) (=> (not (= ?v0 zero$c)) (exists ((?v3 Complex$)) (= (poly$ (pCons$ ?v1 (pCons$ ?v2 ?v0)) ?v3) zero$)))) :named a323))
+(assert (! (forall ((?v0 Complex_poly$) (?v1 Complex_poly_poly$)) (= (dvd$c (pCons$a ?v0 zero$b) ?v1) (forall ((?v2 Nat$)) (dvd$ ?v0 (coeff$ ?v1 ?v2))))) :named a324))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat_poly$)) (= (dvd$d (pCons$b ?v0 zero$d) ?v1) (forall ((?v2 Nat$)) (dvd$b ?v0 (coeff$a ?v1 ?v2))))) :named a325))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (dvd$ (pCons$ ?v0 zero$c) ?v1) (forall ((?v2 Nat$)) (dvd$a ?v0 (coeff$b ?v1 ?v2))))) :named a326))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (degree$a (power$b (pCons$b ?v0 (pCons$b one$ zero$d)) ?v1)) ?v1)) :named a327))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (degree$b (power$ (pCons$ ?v0 (pCons$ one$b zero$c)) ?v1)) ?v1)) :named a328))
+(assert (! (forall ((?v0 Complex_poly$)) (= (pcompose$ ?v0 zero$c) (pCons$ (coeff$b ?v0 zero$a) zero$c))) :named a329))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (coeff$a (power$b (pCons$b ?v0 (pCons$b one$ zero$d)) ?v1) ?v1) one$)) :named a330))
+(assert (! (forall ((?v0 Complex$) (?v1 Nat$)) (= (coeff$b (power$ (pCons$ ?v0 (pCons$ one$b zero$c)) ?v1) ?v1) one$b)) :named a331))
+(assert (! (forall ((?v0 Complex$) (?v1 Complex_poly$)) (= (dvd$ (pCons$ ?v0 ?v1) one$a) (and (= ?v1 zero$c) (not (= ?v0 zero$))))) :named a332))
+(assert (! (forall ((?v0 Complex$)) (=> (not (= ?v0 zero$)) (dvd$ (pCons$ ?v0 zero$c) one$a))) :named a333))
+(assert (! (forall ((?v0 Complex_poly$)) (=> (and (dvd$ ?v0 one$a) (forall ((?v1 Complex$)) (=> (and (= ?v0 (monom$ ?v1 zero$a)) (not (= ?v1 zero$))) false))) false)) :named a334))
+(assert (! (forall ((?v0 Complex$)) (=> (not (= ?v0 zero$)) (dvd$ (monom$ ?v0 zero$a) one$a))) :named a335))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (times$ ?v0 ?v1) (times$ ?v2 ?v1)) (or (= ?v0 ?v2) (= ?v1 zero$a)))) :named a336))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (= (times$ ?v0 ?v1) (times$ ?v0 ?v2)) (or (= ?v1 ?v2) (= ?v0 zero$a)))) :named a337))
+(assert (! (forall ((?v0 Nat$)) (! (= (times$ ?v0 zero$a) zero$a) :pattern ((times$ ?v0)))) :named a338))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (times$ ?v0 ?v1) zero$a) (or (= ?v0 zero$a) (= ?v1 zero$a)))) :named a339))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (suc$ ?v0) (suc$ ?v1)) (= ?v0 ?v1))) :named a340))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (suc$ ?v0) (suc$ ?v1)) (= ?v0 ?v1))) :named a341))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (times$ ?v0 ?v1) one$) (and (= ?v0 one$) (= ?v1 one$)))) :named a342))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= one$ (times$ ?v0 ?v1)) (and (= ?v0 one$) (= ?v1 one$)))) :named a343))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (times$ ?v0 ?v1) (suc$ zero$a)) (and (= ?v0 (suc$ zero$a)) (= ?v1 (suc$ zero$a))))) :named a344))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (suc$ zero$a) (times$ ?v0 ?v1)) (and (= ?v0 (suc$ zero$a)) (= ?v1 (suc$ zero$a))))) :named a345))
+(assert (! (forall ((?v0 Nat$)) (! (= (power$c (suc$ zero$a) ?v0) (suc$ zero$a)) :pattern ((power$c (suc$ zero$a) ?v0)))) :named a346))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (= (power$c ?v0 ?v1) (suc$ zero$a)) (or (= ?v1 zero$a) (= ?v0 (suc$ zero$a))))) :named a347))
+(assert (! (forall ((?v0 Nat$)) (less_eq$ zero$a ?v0)) :named a348))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (less_eq$ (suc$ ?v0) (suc$ ?v1)) (less_eq$ ?v0 ?v1))) :named a349))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (= (plus$a ?v0 (suc$ ?v1)) (suc$ (plus$a ?v0 ?v1)))) :named a350))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$)) (! (= (times$ ?v0 (suc$ ?v1)) (plus$a ?v0 (times$ ?v0 ?v1))) :pattern ((times$ ?v0 (suc$ ?v1))))) :named a351))
+(assert (! (forall ((?v0 Nat$) (?v1 Nat$) (?v2 Nat$)) (= (less_eq$ (plus$a ?v0 ?v1) (plus$a ?v0 ?v2)) (less_eq$ ?v1 ?v2))) :named a352))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic UFLIA)
+(set-info :status sat)
+(declare-fun f1 (Int Int Int Int) Int)
+(declare-fun f2 (Int Int Int) Int)
+(declare-fun f3 (Int Int) Int)
+(declare-fun f4 (Int) Int)
+(declare-fun f5 (Int Int Int) Int)
+(declare-fun f6 (Int Int) Int)
+(declare-fun f7 (Int) Int)
+
+
+(assert (= (f1 0) (f1 1)))
+(assert (= (f1 1) f2))
+
+(assert (= (f2 0) (f2 1)))
+(assert (= (f2 1) f3))
+
+(assert (= (f3 0) (f3 1)))
+(assert (= (f3 1) f4))
+
+(assert (= (f4 0) (f4 1)))
+(assert (= (f4 1) 2))
+
+
+(assert (= (f1 3) (f1 4)))
+(assert (= (f1 4) f5))
+
+(assert (= (f5 3) (f5 4)))
+(assert (= (f5 4) f6))
+
+(assert (= (f6 3) (f6 4)))
+(assert (= (f6 4) f7))
+
+(assert (= (f7 3) (f7 4)))
+(assert (= (f7 4) 5))
+
+; this benchmark has a concise model representation for f1 if we use curried (tree-like) models for UF
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+
+(declare-sort U 0)
+
+(declare-fun p (Int) Bool)
+(declare-fun q (Int) Bool)
+(declare-fun k (Int Int) Int)
+
+(assert (q (k 0 1)))
+(assert (not (p (k 0 0))))
+
+(assert (forall ((f (-> Int Int Int)) (y Int) (z Int)) (or (p (f y z)) (not (q (f z y))))))
+
+(check-sat)
+(exit)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+
+(declare-sort U 0)
+
+(declare-fun p (Int) Bool)
+(declare-fun q (Int) Bool)
+(declare-fun k (Int Int) Int)
+
+(assert (q (k 0 1)))
+(assert (not (p (k 0 0))))
+
+(assert (forall ((f (-> Int Int Int)) (y Int) (z Int)) (or (p (f y z)) (not (q (f 1 y))))))
+;solved by instantiating with {f->\lambda w1w2. (k 0 w1), y-> 0, z-> _ }
+
+(check-sat)
+(exit)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+
+(declare-sort U 0)
+
+(declare-fun p (Int) Bool)
+(declare-fun g (Int) Int)
+
+(assert (not (p (g 0))))
+;(assert (= 0 (g 0)))
+
+(assert (forall ((f (-> Int Int)) (y Int)) (p (f (f (f (f (f y))))))))
+
+(check-sat)
+(exit)
--- /dev/null
+; COMMAND-LINE: --uf-ho --finite-model-find
+; EXPECT: sat
+(set-logic UF)
+(set-info :status sat)
+(declare-sort U 0)
+(declare-fun P (U U) Bool)
+(declare-fun Q (U U) Bool)
+(declare-fun R (U U) Bool)
+(declare-fun a () U)
+(declare-fun b () U)
+
+; can solve this using standard MBQI model for P = \ xy true
+(assert (forall ((x U) (y U)) (or (P x y) (Q x y))))
+(assert (forall ((x U) (y U)) (or (P x y) (R x y))))
+
+(assert (not (= a b)))
+(assert (= (Q a) (R b)))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho --full-saturate-quant
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+(declare-sort Com$ 0)
+(declare-sort Glb$ 0)
+(declare-sort Loc$ 0)
+(declare-sort Nat$ 0)
+(declare-sort Pname$ 0)
+(declare-sort State$ 0)
+(declare-sort Vname$ 0)
+(declare-sort Com_set$ 0)
+(declare-sort Pname_set$ 0)
+(declare-sort Com_option$ 0)
+(declare-sort Pname_option$ 0)
+(declare-sort State_triple$ 0)
+(declare-sort Com_option_set$ 0)
+(declare-sort Pname_option_set$ 0)
+(declare-sort State_triple_set$ 0)
+(declare-sort Com_option_option$ 0)
+(declare-sort State_triple_option$ 0)
+(declare-sort Com_option_option_set$ 0)
+(declare-sort State_triple_option_set$ 0)
+(declare-sort State_triple_option_option$ 0)
+(declare-sort State_triple_option_option_set$ 0)
+(declare-fun c$ () Com$)
+(declare-fun s$ () State$)
+(declare-fun z$ () State$)
+(declare-fun uu$ (Com_set$ Com$) Bool)
+(declare-fun wt$ (Com$) Bool)
+(declare-fun arg$ () Loc$)
+(declare-fun ass$ (Vname$ (-> State$ Nat$)) Com$)
+(declare-fun bot$ () Pname_set$)
+(declare-fun dom$ ((-> State_triple$ State_triple_option$)) State_triple_set$)
+(declare-fun glb$ (Glb$) Vname$)
+(declare-fun loc$ (Loc$) Vname$)
+(declare-fun mgt$ (Com$) State_triple$)
+(declare-fun ran$ ((-> State_triple$ Com_option$)) Com_set$)
+(declare-fun res$ () Loc$)
+(declare-fun suc$ (Nat$) Nat$)
+(declare-fun sup$ (State_triple_set$ State_triple_set$) State_triple_set$)
+(declare-fun the$ (Com_option$) Com$)
+(declare-fun uua$ (State_triple_set$ State_triple$) Bool)
+(declare-fun uub$ (Pname_set$ Pname$) Bool)
+(declare-fun uuc$ ((-> State$ (-> State$ Bool)) State$ Vname$ State$ State$) Bool)
+(declare-fun uud$ ((-> State$ (-> State$ Bool)) State$ (-> State$ Nat$) State$ State$) Bool)
+(declare-fun uue$ (Com$) Com_option$)
+(declare-fun uuf$ (State_triple$) Bool)
+(declare-fun uug$ (Com$) Bool)
+(declare-fun uuh$ (State_triple$) Bool)
+(declare-fun uui$ (Com$) Bool)
+(declare-fun uuj$ ((-> State$ (-> State$ Bool)) Loc$ State$ State$ State$) Bool)
+(declare-fun uuk$ ((-> State$ (-> State$ Bool)) Loc$ State$ (-> State$ Nat$) State$ State$) Bool)
+(declare-fun uul$ ((-> State$ (-> State$ Bool)) (-> State$ Bool) State$ State$) Bool)
+(declare-fun uum$ (Bool (-> State$ (-> State$ Bool)) State$ State$) Bool)
+(declare-fun uun$ (State$ State$ State$) Bool)
+(declare-fun uuo$ ((-> State$ (-> State$ Bool)) State$ State$) (-> State$ Bool))
+(declare-fun uup$ ((-> State$ (-> State$ Bool)) Vname$ (-> State$ Nat$) State$ State$) Bool)
+(declare-fun uuq$ (State$ State$) Bool)
+(declare-fun uur$ ((-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$)
+(declare-fun uus$ ((-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$)
+(declare-fun uut$ (Bool) Bool)
+(declare-fun uuu$ ((-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ Com$) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$)
+(declare-fun uuv$ ((-> Pname$ Com$) (-> Pname$ (-> State$ (-> State$ Bool))) (-> Pname$ (-> State$ (-> State$ Bool))) Pname$) State_triple$)
+(declare-fun uuw$ (Com$ State$ State$) Bool)
+(declare-fun uux$ (Nat$ (-> State$ (-> State$ Bool)) Com$ (-> State$ (-> State$ Bool))) Bool)
+(declare-fun uuy$ (State_triple$) Com_option$)
+(declare-fun uuz$ (Pname$) Com_option$)
+(declare-fun uva$ (State_triple$) State_triple_option$)
+(declare-fun uvb$ (Com$) State_triple_option$)
+(declare-fun uvc$ (Pname$) State_triple_option$)
+(declare-fun uvd$ (State_triple_option$) State_triple_option$)
+(declare-fun uve$ (State_triple_option$) Com_option$)
+(declare-fun uvf$ (Com_option$) State_triple_option$)
+(declare-fun uvg$ (Com_option$) Com_option$)
+(declare-fun uvh$ ((-> State_triple$ Com_option$) State_triple$) Bool)
+(declare-fun uvi$ ((-> Pname$ State_triple_option$) Pname$) Bool)
+(declare-fun uvj$ ((-> Pname$ Com_option$) Pname$) Bool)
+(declare-fun uvk$ ((-> Com$ Com$) Com$) Com_option$)
+(declare-fun bind$ (State_triple_option$ (-> State_triple$ Com_option$)) Com_option$)
+(declare-fun body$ (Pname$) Com_option$)
+(declare-fun bot$a () State_triple_option_set$)
+(declare-fun bot$b () Com_option_set$)
+(declare-fun bot$c () Com_set$)
+(declare-fun bot$d () State_triple_set$)
+(declare-fun bot$e () Pname_option_set$)
+(declare-fun bot$f () State_triple_option_option_set$)
+(declare-fun bot$g () Com_option_option_set$)
+(declare-fun call$ (Vname$ Pname$ (-> State$ Nat$)) Com$)
+(declare-fun comp$ ((-> Bool Bool) (-> State$ Bool)) (-> State$ Bool))
+(declare-fun cond$ ((-> State$ Bool) Com$ Com$) Com$)
+(declare-fun dom$a ((-> Com$ State_triple_option$)) Com_set$)
+(declare-fun dom$b ((-> Com$ Com_option$)) Com_set$)
+(declare-fun dom$c ((-> Pname$ State_triple_option$)) Pname_set$)
+(declare-fun dom$d ((-> State_triple_option$ State_triple_option$)) State_triple_option_set$)
+(declare-fun dom$e ((-> State_triple_option$ Com_option$)) State_triple_option_set$)
+(declare-fun dom$f ((-> Com_option$ State_triple_option$)) Com_option_set$)
+(declare-fun dom$g ((-> Com_option$ Com_option$)) Com_option_set$)
+(declare-fun dom$h ((-> Pname$ Com_option$)) Pname_set$)
+(declare-fun dom$i ((-> State_triple$ Com_option$)) State_triple_set$)
+(declare-fun none$ () Com_option$)
+(declare-fun plus$ (Nat$ Nat$) Nat$)
+(declare-fun ran$a ((-> Pname$ Com_option$)) Com_set$)
+(declare-fun semi$ (Com$ Com$) Com$)
+(declare-fun size$ (State_triple$) Nat$)
+(declare-fun skip$ () Com$)
+(declare-fun some$ (Com$) Com_option$)
+(declare-fun the$a (State_triple_option$) State_triple$)
+(declare-fun the$b (Pname_option$) Pname$)
+(declare-fun zero$ () Nat$)
+(declare-fun bind$a (Com_option$ (-> Com$ State_triple_option$)) State_triple_option$)
+(declare-fun bind$b (State_triple_option$ (-> State_triple$ State_triple_option$)) State_triple_option$)
+(declare-fun bind$c (Com_option$ (-> Com$ Com_option$)) Com_option$)
+(declare-fun body$a (Pname$) Com$)
+(declare-fun evalc$ (Com$ State$ State$) Bool)
+(declare-fun evaln$ (Com$ State$ Nat$ State$) Bool)
+(declare-fun image$ ((-> Pname$ State_triple$) Pname_set$) State_triple_set$)
+(declare-fun local$ (Loc$ (-> State$ Nat$) Com$) Com$)
+(declare-fun minus$ (Com_set$ Com_set$) Com_set$)
+(declare-fun none$a () State_triple_option$)
+(declare-fun none$b () Pname_option$)
+(declare-fun none$c () State_triple_option_option$)
+(declare-fun none$d () Com_option_option$)
+(declare-fun size$a (State_triple_option$) Nat$)
+(declare-fun size$b (Com_option$) Nat$)
+(declare-fun size$c (Vname$) Nat$)
+(declare-fun size$d (Com$) Nat$)
+(declare-fun some$a (State_triple$) State_triple_option$)
+(declare-fun these$ (Pname_option_set$) Pname_set$)
+(declare-fun while$ ((-> State$ Bool) Com$) Com$)
+(declare-fun finite$ (Pname_set$) Bool)
+(declare-fun insert$ (State_triple$ State_triple_set$) State_triple_set$)
+(declare-fun map_le$ ((-> State_triple$ Com_option$) (-> State_triple$ Com_option$)) Bool)
+(declare-fun member$ (State_triple$ State_triple_set$) Bool)
+(declare-fun minus$a (State_triple_option_set$ State_triple_option_set$) State_triple_option_set$)
+(declare-fun minus$b (Com_option_set$ Com_option_set$) Com_option_set$)
+(declare-fun minus$c (State_triple_set$ State_triple_set$) State_triple_set$)
+(declare-fun minus$d (Pname_set$ Pname_set$) Pname_set$)
+(declare-fun these$a (State_triple_option_option_set$) State_triple_option_set$)
+(declare-fun these$b (Com_option_option_set$) Com_option_set$)
+(declare-fun these$c (Com_option_set$) Com_set$)
+(declare-fun these$d (State_triple_option_set$) State_triple_set$)
+(declare-fun triple$ ((-> State$ (-> State$ Bool)) Com$ (-> State$ (-> State$ Bool))) State_triple$)
+(declare-fun uminus$ (State_triple_set$) State_triple_set$)
+(declare-fun update$ (State$ Vname$ Nat$) State$)
+(declare-fun collect$ ((-> Com$ Bool)) Com_set$)
+(declare-fun fun_upd$ ((-> State_triple$ Com_option$) State_triple$ Com_option$) (-> State_triple$ Com_option$))
+(declare-fun getlocs$ (State$) (-> Loc$ Nat$))
+(declare-fun insert$a (Com$ Com_set$) Com_set$)
+(declare-fun insert$b (Pname$ Pname_set$) Pname_set$)
+(declare-fun insert$c (State_triple_option$ State_triple_option_set$) State_triple_option_set$)
+(declare-fun insert$d (Com_option$ Com_option_set$) Com_option_set$)
+(declare-fun insert$e (Pname_option$ Pname_option_set$) Pname_option_set$)
+(declare-fun insert$f (State_triple_option_option$ State_triple_option_option_set$) State_triple_option_option_set$)
+(declare-fun insert$g (Com_option_option$ Com_option_option_set$) Com_option_option_set$)
+(declare-fun map_le$a ((-> Pname$ Com_option$) (-> Pname$ Com_option$)) Bool)
+(declare-fun member$a (Pname$ Pname_set$) Bool)
+(declare-fun member$b (Com$ Com_set$) Bool)
+(declare-fun member$c (State_triple_option$ State_triple_option_set$) Bool)
+(declare-fun member$d (Com_option$ Com_option_set$) Bool)
+(declare-fun newlocs$ () (-> Loc$ Nat$))
+(declare-fun setlocs$ (State$ (-> Loc$ Nat$)) State$)
+(declare-fun collect$a ((-> State_triple$ Bool)) State_triple_set$)
+(declare-fun collect$b ((-> Pname$ Bool)) Pname_set$)
+(declare-fun fun_upd$a ((-> Pname$ Com_option$) Pname$ Com_option$) (-> Pname$ Com_option$))
+(declare-fun fun_upd$b ((-> State_triple$ State_triple_option$) State_triple$ State_triple_option$) (-> State_triple$ State_triple_option$))
+(declare-fun fun_upd$c ((-> Com$ State_triple_option$) Com$ State_triple_option$) (-> Com$ State_triple_option$))
+(declare-fun fun_upd$d ((-> Com$ Com_option$) Com$ Com_option$) (-> Com$ Com_option$))
+(declare-fun fun_upd$e ((-> Pname$ State_triple_option$) Pname$ State_triple_option$) (-> Pname$ State_triple_option$))
+(declare-fun fun_upd$f ((-> State_triple_option$ State_triple_option$) State_triple_option$ State_triple_option$) (-> State_triple_option$ State_triple_option$))
+(declare-fun fun_upd$g ((-> State_triple_option$ Com_option$) State_triple_option$ Com_option$) (-> State_triple_option$ Com_option$))
+(declare-fun fun_upd$h ((-> Com_option$ State_triple_option$) Com_option$ State_triple_option$) (-> Com_option$ State_triple_option$))
+(declare-fun fun_upd$i ((-> Com_option$ Com_option$) Com_option$ Com_option$) (-> Com_option$ Com_option$))
+(declare-fun peek_and$ ((-> State$ (-> State$ Bool)) (-> State$ Bool)) (-> State$ (-> State$ Bool)))
+(declare-fun size_com$ (Com$) Nat$)
+(declare-fun wT_bodies$ () Bool)
+(declare-fun map_option$ ((-> Com$ Com$) Com_option$) Com_option$)
+(declare-fun set_option$ (Pname_option$) Pname_set$)
+(declare-fun size_vname$ (Vname$) Nat$)
+(declare-fun case_option$ (Bool (-> Com$ Bool) Com_option$) Bool)
+(declare-fun case_triple$ ((-> (-> State$ (-> State$ Bool)) (-> Com$ (-> (-> State$ (-> State$ Bool)) Bool))) State_triple$) Bool)
+(declare-fun map_option$a ((-> State_triple$ Com$) State_triple_option$) Com_option$)
+(declare-fun map_option$b ((-> Com$ State_triple$) Com_option$) State_triple_option$)
+(declare-fun map_option$c ((-> State_triple$ State_triple$) State_triple_option$) State_triple_option$)
+(declare-fun set_option$a (State_triple_option$) State_triple_set$)
+(declare-fun set_option$b (Com_option$) Com_set$)
+(declare-fun set_option$c (State_triple_option_option$) State_triple_option_set$)
+(declare-fun set_option$d (Com_option_option$) Com_option_set$)
+(declare-fun size_option$ ((-> State_triple$ Nat$)) (-> State_triple_option$ Nat$))
+(declare-fun size_triple$ ((-> State$ Nat$) State_triple$) Nat$)
+(declare-fun case_option$a (Bool (-> State_triple$ Bool) State_triple_option$) Bool)
+(declare-fun case_option$b (Com_option$ (-> Com$ Com_option$) Com_option$) Com_option$)
+(declare-fun hoare_derivs$ (State_triple_set$ State_triple_set$) Bool)
+(declare-fun hoare_valids$ (State_triple_set$ State_triple_set$) Bool)
+(declare-fun restrict_map$ ((-> Com$ Com_option$) Com_set$) (-> Com$ Com_option$))
+(declare-fun size_option$a ((-> Com$ Nat$)) (-> Com_option$ Nat$))
+(declare-fun triple_valid$ (Nat$ State_triple$) Bool)
+(declare-fun restrict_map$a ((-> Com$ State_triple_option$) Com_set$) (-> Com$ State_triple_option$))
+(declare-fun restrict_map$b ((-> State_triple_option$ Com_option$) State_triple_option_set$) (-> State_triple_option$ Com_option$))
+(declare-fun restrict_map$c ((-> State_triple_option$ State_triple_option$) State_triple_option_set$) (-> State_triple_option$ State_triple_option$))
+(declare-fun restrict_map$d ((-> Com_option$ Com_option$) Com_option_set$) (-> Com_option$ Com_option$))
+(declare-fun restrict_map$e ((-> Com_option$ State_triple_option$) Com_option_set$) (-> Com_option$ State_triple_option$))
+(declare-fun restrict_map$f ((-> State_triple$ State_triple_option$) State_triple_set$) (-> State_triple$ State_triple_option$))
+(declare-fun restrict_map$g ((-> Pname$ Com_option$) Pname_set$) (-> Pname$ Com_option$))
+(declare-fun restrict_map$h ((-> Pname$ State_triple_option$) Pname_set$) (-> Pname$ State_triple_option$))
+(declare-fun restrict_map$i ((-> State_triple$ Com_option$) State_triple_set$) (-> State_triple$ Com_option$))
+(declare-fun state_not_singleton$ () Bool)
+(assert (! (forall ((?v0 Bool)) (! (= (uut$ ?v0) (not ?v0)) :pattern ((uut$ ?v0)))) :named a0))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (! (= (uua$ ?v0 ?v1) (member$ ?v1 ?v0)) :pattern ((uua$ ?v0 ?v1)))) :named a1))
+(assert (! (forall ((?v0 Pname_set$) (?v1 Pname$)) (! (= (uub$ ?v0 ?v1) (member$a ?v1 ?v0)) :pattern ((uub$ ?v0 ?v1)))) :named a2))
+(assert (! (forall ((?v0 Com_set$) (?v1 Com$)) (! (= (uu$ ?v0 ?v1) (member$b ?v1 ?v0)) :pattern ((uu$ ?v0 ?v1)))) :named a3))
+(assert (! (forall ((?v0 State$) (?v1 State$)) (! (= (uuq$ ?v0 ?v1) (= ?v0 ?v1)) :pattern ((uuq$ ?v0 ?v1)))) :named a4))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (! (= (uvh$ ?v0 ?v1) (not (= (?v0 ?v1) none$))) :pattern ((uvh$ ?v0 ?v1)))) :named a5))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (! (= (uvi$ ?v0 ?v1) (not (= (?v0 ?v1) none$a))) :pattern ((uvi$ ?v0 ?v1)))) :named a6))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (! (= (uvj$ ?v0 ?v1) (not (= (?v0 ?v1) none$))) :pattern ((uvj$ ?v0 ?v1)))) :named a7))
+(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com$)) (! (= (uvk$ ?v0 ?v1) (some$ (?v0 ?v1))) :pattern ((uvk$ ?v0 ?v1)))) :named a8))
+(assert (! (forall ((?v0 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 Pname$)) (! (= (uus$ ?v0 ?v1 ?v2) (triple$ (?v0 ?v2) (the$ (body$ ?v2)) (?v1 ?v2))) :pattern ((uus$ ?v0 ?v1 ?v2)))) :named a9))
+(assert (! (forall ((?v0 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 Pname$)) (! (= (uur$ ?v0 ?v1 ?v2) (triple$ (?v0 ?v2) (body$a ?v2) (?v1 ?v2))) :pattern ((uur$ ?v0 ?v1 ?v2)))) :named a10))
+(assert (! (forall ((?v0 State$) (?v1 State$) (?v2 State$)) (! (= (uun$ ?v0 ?v1 ?v2) (= ?v2 ?v0)) :pattern ((uun$ ?v0 ?v1 ?v2)))) :named a11))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State$) (?v2 State$)) (! (= (uuo$ ?v0 ?v1 ?v2) (?v0 ?v1)) :pattern ((uuo$ ?v0 ?v1 ?v2)))) :named a12))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$)) (! (= (uuw$ ?v0 ?v1 ?v2) (forall ((?v3 State$)) (=> (evalc$ ?v0 ?v2 ?v3) (= ?v1 ?v3)))) :pattern ((uuw$ ?v0 ?v1 ?v2)))) :named a13))
+(assert (! (forall ((?v0 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v1 (-> Pname$ Com$)) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname$)) (! (= (uuu$ ?v0 ?v1 ?v2 ?v3) (triple$ (?v0 ?v3) (?v1 ?v3) (?v2 ?v3))) :pattern ((uuu$ ?v0 ?v1 ?v2 ?v3)))) :named a14))
+(assert (! (forall ((?v0 (-> Pname$ Com$)) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname$)) (! (= (uuv$ ?v0 ?v1 ?v2 ?v3) (triple$ (?v1 ?v3) (?v0 ?v3) (?v2 ?v3))) :pattern ((uuv$ ?v0 ?v1 ?v2 ?v3)))) :named a15))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 (-> State$ Bool)) (?v2 State$) (?v3 State$)) (! (= (uul$ ?v0 ?v1 ?v2 ?v3) (and (?v0 ?v2 ?v3) (not (?v1 ?v3)))) :pattern ((uul$ ?v0 ?v1 ?v2 ?v3)))) :named a16))
+(assert (! (forall ((?v0 Bool) (?v1 (-> State$ (-> State$ Bool))) (?v2 State$) (?v3 State$)) (! (= (uum$ ?v0 ?v1 ?v2 ?v3) (and (?v1 ?v2 ?v3) ?v0)) :pattern ((uum$ ?v0 ?v1 ?v2 ?v3)))) :named a17))
+(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (! (= (uux$ ?v0 ?v1 ?v2 ?v3) (forall ((?v4 State$) (?v5 State$)) (=> (?v1 ?v4 ?v5) (forall ((?v6 State$)) (=> (evaln$ ?v2 ?v5 ?v0 ?v6) (?v3 ?v4 ?v6)))))) :pattern ((uux$ ?v0 ?v1 ?v2 ?v3)))) :named a18))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State$) (?v2 Vname$) (?v3 State$) (?v4 State$)) (! (= (uuc$ ?v0 ?v1 ?v2 ?v3 ?v4) (?v0 ?v3 (update$ (setlocs$ ?v4 (getlocs$ ?v1)) ?v2 (getlocs$ ?v4 res$)))) :pattern ((uuc$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a19))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Loc$) (?v2 State$) (?v3 State$) (?v4 State$)) (! (= (uuj$ ?v0 ?v1 ?v2 ?v3 ?v4) (?v0 ?v3 (update$ ?v4 (loc$ ?v1) (getlocs$ ?v2 ?v1)))) :pattern ((uuj$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a20))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Vname$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 State$)) (! (= (uup$ ?v0 ?v1 ?v2 ?v3 ?v4) (?v0 ?v3 (update$ ?v4 ?v1 (?v2 ?v4)))) :pattern ((uup$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a21))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 State$)) (! (= (uud$ ?v0 ?v1 ?v2 ?v3 ?v4) (and (= ?v1 ?v4) (?v0 ?v3 (update$ (setlocs$ ?v4 newlocs$) (loc$ arg$) (?v2 ?v4))))) :pattern ((uud$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a22))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Loc$) (?v2 State$) (?v3 (-> State$ Nat$)) (?v4 State$) (?v5 State$)) (! (= (uuk$ ?v0 ?v1 ?v2 ?v3 ?v4 ?v5) (and (= ?v2 ?v5) (?v0 ?v4 (update$ ?v5 (loc$ ?v1) (?v3 ?v5))))) :pattern ((uuk$ ?v0 ?v1 ?v2 ?v3 ?v4 ?v5)))) :named a23))
+(assert (! (forall ((?v0 State_triple$)) (! (= (uva$ ?v0) none$a) :pattern ((uva$ ?v0)))) :named a24))
+(assert (! (forall ((?v0 State_triple$)) (! (= (uuy$ ?v0) none$) :pattern ((uuy$ ?v0)))) :named a25))
+(assert (! (forall ((?v0 State_triple_option$)) (! (= (uvd$ ?v0) none$a) :pattern ((uvd$ ?v0)))) :named a26))
+(assert (! (forall ((?v0 State_triple_option$)) (! (= (uve$ ?v0) none$) :pattern ((uve$ ?v0)))) :named a27))
+(assert (! (forall ((?v0 Com_option$)) (! (= (uvf$ ?v0) none$a) :pattern ((uvf$ ?v0)))) :named a28))
+(assert (! (forall ((?v0 Com_option$)) (! (= (uvg$ ?v0) none$) :pattern ((uvg$ ?v0)))) :named a29))
+(assert (! (forall ((?v0 Pname$)) (! (= (uvc$ ?v0) none$a) :pattern ((uvc$ ?v0)))) :named a30))
+(assert (! (forall ((?v0 Pname$)) (! (= (uuz$ ?v0) none$) :pattern ((uuz$ ?v0)))) :named a31))
+(assert (! (forall ((?v0 Com$)) (! (= (uvb$ ?v0) none$a) :pattern ((uvb$ ?v0)))) :named a32))
+(assert (! (forall ((?v0 Com$)) (! (= (uue$ ?v0) none$) :pattern ((uue$ ?v0)))) :named a33))
+(assert (! (forall ((?v0 State_triple$)) (! (= (uuh$ ?v0) false) :pattern ((uuh$ ?v0)))) :named a34))
+(assert (! (forall ((?v0 Com$)) (! (= (uui$ ?v0) false) :pattern ((uui$ ?v0)))) :named a35))
+(assert (! (forall ((?v0 State_triple$)) (! (= (uuf$ ?v0) true) :pattern ((uuf$ ?v0)))) :named a36))
+(assert (! (forall ((?v0 Com$)) (! (= (uug$ ?v0) true) :pattern ((uug$ ?v0)))) :named a37))
+(assert (! (not false) :named a38))
+(assert (! (forall ((?v0 State$)) (= ?v0 s$)) :named a39))
+(assert (! (forall ((?v0 State$)) (not (evalc$ c$ z$ ?v0))) :named a40))
+(assert (! (forall ((?v0 State$)) (=> (forall ((?v1 State$)) (= ?v1 ?v0)) false)) :named a41))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$) (?v3 State$)) (=> (and (evalc$ ?v0 ?v1 ?v2) (evalc$ ?v0 ?v1 ?v3)) (= ?v3 ?v2))) :named a42))
+(assert (! (=> state_not_singleton$ (forall ((?v0 State$)) (=> (forall ((?v1 State$)) (= ?v1 ?v0)) false))) :named a43))
+(assert (! (= state_not_singleton$ (exists ((?v0 State$) (?v1 State$)) (not (= ?v0 ?v1)))) :named a44))
+(assert (! (forall ((?v0 State$) (?v1 State$)) (=> (and (evalc$ skip$ ?v0 ?v1) (=> (= ?v1 ?v0) false)) false)) :named a45))
+(assert (! (forall ((?v0 State$)) (evalc$ skip$ ?v0 ?v0)) :named a46))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 State$) (?v3 State$)) (=> (and (evalc$ (semi$ ?v0 ?v1) ?v2 ?v3) (forall ((?v4 State$)) (=> (and (evalc$ ?v0 ?v2 ?v4) (evalc$ ?v1 ?v4 ?v3)) false))) false)) :named a47))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$) (?v3 Com$) (?v4 State$)) (=> (and (evalc$ ?v0 ?v1 ?v2) (evalc$ ?v3 ?v2 ?v4)) (evalc$ (semi$ ?v0 ?v3) ?v1 ?v4))) :named a48))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 State$) (?v4 State$)) (=> (and (evalc$ (cond$ ?v0 ?v1 ?v2) ?v3 ?v4) (and (=> (and (?v0 ?v3) (evalc$ ?v1 ?v3 ?v4)) false) (=> (and (not (?v0 ?v3)) (evalc$ ?v2 ?v3 ?v4)) false))) false)) :named a49))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 State$) (?v4 Com$)) (=> (and (?v0 ?v1) (evalc$ ?v2 ?v1 ?v3)) (evalc$ (cond$ ?v0 ?v2 ?v4) ?v1 ?v3))) :named a50))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 State$) (?v4 Com$)) (=> (and (not (?v0 ?v1)) (evalc$ ?v2 ?v1 ?v3)) (evalc$ (cond$ ?v0 ?v4 ?v2) ?v1 ?v3))) :named a51))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 State$) (?v4 State$)) (=> (and (?v0 ?v1) (and (evalc$ ?v2 ?v1 ?v3) (evalc$ (while$ ?v0 ?v2) ?v3 ?v4))) (evalc$ (while$ ?v0 ?v2) ?v1 ?v4))) :named a52))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$)) (=> (not (?v0 ?v1)) (evalc$ (while$ ?v0 ?v2) ?v1 ?v1))) :named a53))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 State$) (?v3 State$)) (=> (and (evalc$ (while$ ?v0 ?v1) ?v2 ?v3) (and (=> (and (= ?v3 ?v2) (not (?v0 ?v2))) false) (forall ((?v4 State$)) (=> (and (?v0 ?v2) (and (evalc$ ?v1 ?v2 ?v4) (evalc$ (while$ ?v0 ?v1) ?v4 ?v3))) false)))) false)) :named a54))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 Com$) (?v3 Com$)) (= (= (semi$ ?v0 ?v1) (semi$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a55))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$) (?v5 Com$)) (= (= (cond$ ?v0 ?v1 ?v2) (cond$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a56))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 (-> State$ Bool)) (?v3 Com$)) (= (= (while$ ?v0 ?v1) (while$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a57))
+(assert (! (forall ((?v0 Com$) (?v1 Com$)) (not (= skip$ (semi$ ?v0 ?v1)))) :named a58))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (not (= skip$ (cond$ ?v0 ?v1 ?v2)))) :named a59))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 Com$)) (not (= (semi$ ?v0 ?v1) (cond$ ?v2 ?v3 ?v4)))) :named a60))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (not (= skip$ (while$ ?v0 ?v1)))) :named a61))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 (-> State$ Bool)) (?v3 Com$)) (not (= (semi$ ?v0 ?v1) (while$ ?v2 ?v3)))) :named a62))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$)) (not (= (cond$ ?v0 ?v1 ?v2) (while$ ?v3 ?v4)))) :named a63))
+(assert (! (forall ((?v0 State$) (?v1 Nat$) (?v2 State$)) (=> (and (evaln$ skip$ ?v0 ?v1 ?v2) (=> (= ?v2 ?v0) false)) false)) :named a64))
+(assert (! (forall ((?v0 State$) (?v1 Nat$)) (evaln$ skip$ ?v0 ?v1 ?v0)) :named a65))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$) (?v4 Com$) (?v5 State$) (?v6 Nat$) (?v7 State$)) (=> (and (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v4 ?v5 ?v6 ?v7)) (exists ((?v8 Nat$)) (and (evaln$ ?v0 ?v1 ?v8 ?v3) (evaln$ ?v4 ?v5 ?v8 ?v7))))) :named a66))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$)) (= (evalc$ ?v0 ?v1 ?v2) (exists ((?v3 Nat$)) (evaln$ ?v0 ?v1 ?v3 ?v2)))) :named a67))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 State$)) (=> (evalc$ ?v0 ?v1 ?v2) (exists ((?v3 Nat$)) (evaln$ ?v0 ?v1 ?v3 ?v2)))) :named a68))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (evaln$ ?v0 ?v1 ?v2 ?v3) (evalc$ ?v0 ?v1 ?v3))) :named a69))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (while$ ?v0 ?v1) ?v2 ?v3 ?v4) (and (=> (and (= ?v4 ?v2) (not (?v0 ?v2))) false) (forall ((?v5 State$)) (=> (and (?v0 ?v2) (and (evaln$ ?v1 ?v2 ?v3 ?v5) (evaln$ (while$ ?v0 ?v1) ?v5 ?v3 ?v4))) false)))) false)) :named a70))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$)) (=> (not (?v0 ?v1)) (evaln$ (while$ ?v0 ?v2) ?v1 ?v3 ?v1))) :named a71))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$) (?v4 State$) (?v5 State$)) (=> (and (?v0 ?v1) (and (evaln$ ?v2 ?v1 ?v3 ?v4) (evaln$ (while$ ?v0 ?v2) ?v4 ?v3 ?v5))) (evaln$ (while$ ?v0 ?v2) ?v1 ?v3 ?v5))) :named a72))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$) (?v4 State$) (?v5 Com$)) (=> (and (not (?v0 ?v1)) (evaln$ ?v2 ?v1 ?v3 ?v4)) (evaln$ (cond$ ?v0 ?v5 ?v2) ?v1 ?v3 ?v4))) :named a73))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 State$) (?v2 Com$) (?v3 Nat$) (?v4 State$) (?v5 Com$)) (=> (and (?v0 ?v1) (evaln$ ?v2 ?v1 ?v3 ?v4)) (evaln$ (cond$ ?v0 ?v2 ?v5) ?v1 ?v3 ?v4))) :named a74))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 State$) (?v4 Nat$) (?v5 State$)) (=> (and (evaln$ (cond$ ?v0 ?v1 ?v2) ?v3 ?v4 ?v5) (and (=> (and (?v0 ?v3) (evaln$ ?v1 ?v3 ?v4 ?v5)) false) (=> (and (not (?v0 ?v3)) (evaln$ ?v2 ?v3 ?v4 ?v5)) false))) false)) :named a75))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$) (?v4 Com$) (?v5 State$)) (=> (and (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v4 ?v3 ?v2 ?v5)) (evaln$ (semi$ ?v0 ?v4) ?v1 ?v2 ?v5))) :named a76))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (semi$ ?v0 ?v1) ?v2 ?v3 ?v4) (forall ((?v5 State$)) (=> (and (evaln$ ?v0 ?v2 ?v3 ?v5) (evaln$ ?v1 ?v5 ?v3 ?v4)) false))) false)) :named a77))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (not (= skip$ (ass$ ?v0 ?v1)))) :named a78))
+(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Bool))) (= (member$b ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a79))
+(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Bool))) (= (member$ ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a80))
+(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Bool))) (= (member$a ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a81))
+(assert (! (forall ((?v0 Com_set$)) (= (collect$ (uu$ ?v0)) ?v0)) :named a82))
+(assert (! (forall ((?v0 State_triple_set$)) (= (collect$a (uua$ ?v0)) ?v0)) :named a83))
+(assert (! (forall ((?v0 Pname_set$)) (= (collect$b (uub$ ?v0)) ?v0)) :named a84))
+(assert (! (forall ((?v0 (-> Pname$ Bool)) (?v1 (-> Pname$ Bool))) (=> (forall ((?v2 Pname$)) (= (?v0 ?v2) (?v1 ?v2))) (= (collect$b ?v0) (collect$b ?v1)))) :named a85))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (not (= skip$ (local$ ?v0 ?v1 ?v2)))) :named a86))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Vname$) (?v3 (-> State$ Nat$))) (= (= (ass$ ?v0 ?v1) (ass$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a87))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Loc$) (?v4 (-> State$ Nat$)) (?v5 Com$)) (= (= (local$ ?v0 ?v1 ?v2) (local$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a88))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Loc$) (?v3 (-> State$ Nat$)) (?v4 Com$)) (not (= (ass$ ?v0 ?v1) (local$ ?v2 ?v3 ?v4)))) :named a89))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$)) (not (= (local$ ?v0 ?v1 ?v2) (while$ ?v3 ?v4)))) :named a90))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 (-> State$ Bool)) (?v3 Com$)) (not (= (ass$ ?v0 ?v1) (while$ ?v2 ?v3)))) :named a91))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 (-> State$ Bool)) (?v4 Com$) (?v5 Com$)) (not (= (local$ ?v0 ?v1 ?v2) (cond$ ?v3 ?v4 ?v5)))) :named a92))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 Com$)) (not (= (ass$ ?v0 ?v1) (cond$ ?v2 ?v3 ?v4)))) :named a93))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Com$) (?v4 Com$)) (not (= (local$ ?v0 ?v1 ?v2) (semi$ ?v3 ?v4)))) :named a94))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Com$)) (not (= (ass$ ?v0 ?v1) (semi$ ?v2 ?v3)))) :named a95))
+(assert (! (forall ((?v0 Com$)) (=> (and (=> (= ?v0 skip$) false) (and (forall ((?v1 Vname$) (?v2 (-> State$ Nat$))) (=> (= ?v0 (ass$ ?v1 ?v2)) false)) (and (forall ((?v1 Loc$) (?v2 (-> State$ Nat$)) (?v3 Com$)) (=> (= ?v0 (local$ ?v1 ?v2 ?v3)) false)) (and (forall ((?v1 Com$) (?v2 Com$)) (=> (= ?v0 (semi$ ?v1 ?v2)) false)) (and (forall ((?v1 (-> State$ Bool)) (?v2 Com$) (?v3 Com$)) (=> (= ?v0 (cond$ ?v1 ?v2 ?v3)) false)) (and (forall ((?v1 (-> State$ Bool)) (?v2 Com$)) (=> (= ?v0 (while$ ?v1 ?v2)) false)) (and (forall ((?v1 Pname$)) (=> (= ?v0 (body$a ?v1)) false)) (forall ((?v1 Vname$) (?v2 Pname$) (?v3 (-> State$ Nat$))) (=> (= ?v0 (call$ ?v1 ?v2 ?v3)) false))))))))) false)) :named a96))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$)) (evalc$ (ass$ ?v0 ?v1) ?v2 (update$ ?v2 ?v0 (?v1 ?v2)))) :named a97))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$) (?v3 State$)) (=> (and (evalc$ (ass$ ?v0 ?v1) ?v2 ?v3) (=> (= ?v3 (update$ ?v2 ?v0 (?v1 ?v2))) false)) false)) :named a98))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$) (?v3 Nat$)) (evaln$ (ass$ ?v0 ?v1) ?v2 ?v3 (update$ ?v2 ?v0 (?v1 ?v2)))) :named a99))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (ass$ ?v0 ?v1) ?v2 ?v3 ?v4) (=> (= ?v4 (update$ ?v2 ?v0 (?v1 ?v2))) false)) false)) :named a100))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (not (= skip$ (call$ ?v0 ?v1 ?v2)))) :named a101))
+(assert (! (forall ((?v0 Pname$) (?v1 Pname$)) (= (= (body$a ?v0) (body$a ?v1)) (= ?v0 ?v1))) :named a102))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$)) (?v3 Vname$) (?v4 Pname$) (?v5 (-> State$ Nat$))) (= (= (call$ ?v0 ?v1 ?v2) (call$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a103))
+(assert (! (forall ((?v0 Pname$) (?v1 Vname$) (?v2 Pname$) (?v3 (-> State$ Nat$))) (not (= (body$a ?v0) (call$ ?v1 ?v2 ?v3)))) :named a104))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Pname$)) (not (= (while$ ?v0 ?v1) (body$a ?v2)))) :named a105))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 Pname$)) (not (= (cond$ ?v0 ?v1 ?v2) (body$a ?v3)))) :named a106))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 Pname$)) (not (= (semi$ ?v0 ?v1) (body$a ?v2)))) :named a107))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Pname$)) (not (= (local$ ?v0 ?v1 ?v2) (body$a ?v3)))) :named a108))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Pname$)) (not (= (ass$ ?v0 ?v1) (body$a ?v2)))) :named a109))
+(assert (! (forall ((?v0 Pname$)) (not (= skip$ (body$a ?v0)))) :named a110))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Vname$) (?v3 Pname$) (?v4 (-> State$ Nat$))) (not (= (while$ ?v0 ?v1) (call$ ?v2 ?v3 ?v4)))) :named a111))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$) (?v3 Vname$) (?v4 Pname$) (?v5 (-> State$ Nat$))) (not (= (cond$ ?v0 ?v1 ?v2) (call$ ?v3 ?v4 ?v5)))) :named a112))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 Vname$) (?v3 Pname$) (?v4 (-> State$ Nat$))) (not (= (semi$ ?v0 ?v1) (call$ ?v2 ?v3 ?v4)))) :named a113))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 Vname$) (?v4 Pname$) (?v5 (-> State$ Nat$))) (not (= (local$ ?v0 ?v1 ?v2) (call$ ?v3 ?v4 ?v5)))) :named a114))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$)) (?v2 Vname$) (?v3 Pname$) (?v4 (-> State$ Nat$))) (not (= (ass$ ?v0 ?v1) (call$ ?v2 ?v3 ?v4)))) :named a115))
+(assert (! (forall ((?v0 Com$)) (= (wt$ ?v0) (or (= ?v0 skip$) (or (exists ((?v1 Vname$) (?v2 (-> State$ Nat$))) (= ?v0 (ass$ ?v1 ?v2))) (or (exists ((?v1 Com$) (?v2 Loc$) (?v3 (-> State$ Nat$))) (and (= ?v0 (local$ ?v2 ?v3 ?v1)) (wt$ ?v1))) (or (exists ((?v1 Com$) (?v2 Com$)) (and (= ?v0 (semi$ ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2)))) (or (exists ((?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool))) (and (= ?v0 (cond$ ?v3 ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2)))) (or (exists ((?v1 Com$) (?v2 (-> State$ Bool))) (and (= ?v0 (while$ ?v2 ?v1)) (wt$ ?v1))) (or (exists ((?v1 Pname$)) (and (= ?v0 (body$a ?v1)) (not (= (body$ ?v1) none$)))) (exists ((?v1 Pname$) (?v2 Vname$) (?v3 (-> State$ Nat$))) (and (= ?v0 (call$ ?v2 ?v1 ?v3)) (wt$ (body$a ?v1))))))))))))) :named a116))
+(assert (! (forall ((?v0 Com$)) (=> (and (wt$ ?v0) (and (=> (= ?v0 skip$) false) (and (forall ((?v1 Vname$) (?v2 (-> State$ Nat$))) (=> (= ?v0 (ass$ ?v1 ?v2)) false)) (and (forall ((?v1 Com$) (?v2 Loc$) (?v3 (-> State$ Nat$))) (=> (and (= ?v0 (local$ ?v2 ?v3 ?v1)) (wt$ ?v1)) false)) (and (forall ((?v1 Com$) (?v2 Com$)) (=> (and (= ?v0 (semi$ ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2))) false)) (and (forall ((?v1 Com$) (?v2 Com$) (?v3 (-> State$ Bool))) (=> (and (= ?v0 (cond$ ?v3 ?v1 ?v2)) (and (wt$ ?v1) (wt$ ?v2))) false)) (and (forall ((?v1 Com$) (?v2 (-> State$ Bool))) (=> (and (= ?v0 (while$ ?v2 ?v1)) (wt$ ?v1)) false)) (and (forall ((?v1 Pname$)) (=> (and (= ?v0 (body$a ?v1)) (not (= (body$ ?v1) none$))) false)) (forall ((?v1 Pname$) (?v2 Vname$) (?v3 (-> State$ Nat$))) (=> (and (= ?v0 (call$ ?v2 ?v1 ?v3)) (wt$ (body$a ?v1))) false)))))))))) false)) :named a117))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (=> (and (wt$ (call$ ?v0 ?v1 ?v2)) (=> (wt$ (body$a ?v1)) false)) false)) :named a118))
+(assert (! (forall ((?v0 Pname$) (?v1 Vname$) (?v2 (-> State$ Nat$))) (=> (wt$ (body$a ?v0)) (wt$ (call$ ?v1 ?v0 ?v2)))) :named a119))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 State$) (?v4 State$)) (=> (and (evalc$ (local$ ?v0 ?v1 ?v2) ?v3 ?v4) (forall ((?v5 State$)) (=> (and (= ?v4 (update$ ?v5 (loc$ ?v0) (getlocs$ ?v3 ?v0))) (evalc$ ?v2 (update$ ?v3 (loc$ ?v0) (?v1 ?v3)) ?v5)) false))) false)) :named a120))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Loc$) (?v3 (-> State$ Nat$)) (?v4 State$)) (=> (evalc$ ?v0 (update$ ?v1 (loc$ ?v2) (?v3 ?v1)) ?v4) (evalc$ (local$ ?v2 ?v3 ?v0) ?v1 (update$ ?v4 (loc$ ?v2) (getlocs$ ?v1 ?v2))))) :named a121))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Loc$) (?v3 (-> State$ Nat$)) (?v4 Nat$) (?v5 State$)) (=> (evaln$ ?v0 (update$ ?v1 (loc$ ?v2) (?v3 ?v1)) ?v4 ?v5) (evaln$ (local$ ?v2 ?v3 ?v0) ?v1 ?v4 (update$ ?v5 (loc$ ?v2) (getlocs$ ?v1 ?v2))))) :named a122))
+(assert (! (forall ((?v0 Loc$) (?v1 Loc$)) (= (= (loc$ ?v0) (loc$ ?v1)) (= ?v0 ?v1))) :named a123))
+(assert (! (forall ((?v0 Pname$)) (=> (not (= (body$ ?v0) none$)) (wt$ (body$a ?v0)))) :named a124))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (=> (and (wt$ (while$ ?v0 ?v1)) (=> (wt$ ?v1) false)) false)) :named a125))
+(assert (! (forall ((?v0 Com$) (?v1 (-> State$ Bool))) (=> (wt$ ?v0) (wt$ (while$ ?v1 ?v0)))) :named a126))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (=> (and (wt$ (cond$ ?v0 ?v1 ?v2)) (=> (and (wt$ ?v1) (wt$ ?v2)) false)) false)) :named a127))
+(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 (-> State$ Bool))) (=> (and (wt$ ?v0) (wt$ ?v1)) (wt$ (cond$ ?v2 ?v0 ?v1)))) :named a128))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (wt$ (ass$ ?v0 ?v1))) :named a129))
+(assert (! (forall ((?v0 Com$) (?v1 Loc$) (?v2 (-> State$ Nat$))) (=> (wt$ ?v0) (wt$ (local$ ?v1 ?v2 ?v0)))) :named a130))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (=> (and (wt$ (ass$ ?v0 ?v1)) false) false)) :named a131))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (=> (and (wt$ (local$ ?v0 ?v1 ?v2)) (=> (wt$ ?v2) false)) false)) :named a132))
+(assert (! (forall ((?v0 Com$) (?v1 Com$)) (=> (and (wt$ (semi$ ?v0 ?v1)) (=> (and (wt$ ?v0) (wt$ ?v1)) false)) false)) :named a133))
+(assert (! (forall ((?v0 Com$) (?v1 Com$)) (=> (and (wt$ ?v0) (wt$ ?v1)) (wt$ (semi$ ?v0 ?v1)))) :named a134))
+(assert (! (=> (and (wt$ skip$) false) false) :named a135))
+(assert (! (wt$ skip$) :named a136))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$) (?v3 State$) (?v4 Nat$) (?v5 State$)) (=> (and (evaln$ (local$ ?v0 ?v1 ?v2) ?v3 ?v4 ?v5) (forall ((?v6 State$)) (=> (and (= ?v5 (update$ ?v6 (loc$ ?v0) (getlocs$ ?v3 ?v0))) (evaln$ ?v2 (update$ ?v3 (loc$ ?v0) (?v1 ?v3)) ?v4 ?v6)) false))) false)) :named a137))
+(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 State$)) (=> (evalc$ (the$ (body$ ?v0)) ?v1 ?v2) (evalc$ (body$a ?v0) ?v1 ?v2))) :named a138))
+(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 State$)) (=> (and (evalc$ (body$a ?v0) ?v1 ?v2) (=> (evalc$ (the$ (body$ ?v0)) ?v1 ?v2) false)) false)) :named a139))
+(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 Vname$)) (=> (evalc$ (body$a ?v0) (update$ (setlocs$ ?v1 newlocs$) (loc$ arg$) (?v2 ?v1)) ?v3) (evalc$ (call$ ?v4 ?v0 ?v2) ?v1 (update$ (setlocs$ ?v3 (getlocs$ ?v1)) ?v4 (getlocs$ ?v3 res$))))) :named a140))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 State$)) (=> (and (evalc$ (call$ ?v0 ?v1 ?v2) ?v3 ?v4) (forall ((?v5 State$)) (=> (and (= ?v4 (update$ (setlocs$ ?v5 (getlocs$ ?v3)) ?v0 (getlocs$ ?v5 res$))) (evalc$ (body$a ?v1) (update$ (setlocs$ ?v3 newlocs$) (loc$ arg$) (?v2 ?v3)) ?v5)) false))) false)) :named a141))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$)) (?v3 State$) (?v4 Nat$) (?v5 State$)) (=> (and (evaln$ (call$ ?v0 ?v1 ?v2) ?v3 ?v4 ?v5) (forall ((?v6 State$)) (=> (and (= ?v5 (update$ (setlocs$ ?v6 (getlocs$ ?v3)) ?v0 (getlocs$ ?v6 res$))) (evaln$ (body$a ?v1) (update$ (setlocs$ ?v3 newlocs$) (loc$ arg$) (?v2 ?v3)) ?v4 ?v6)) false))) false)) :named a142))
+(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 (-> State$ Nat$)) (?v3 Nat$) (?v4 State$) (?v5 Vname$)) (=> (evaln$ (body$a ?v0) (update$ (setlocs$ ?v1 newlocs$) (loc$ arg$) (?v2 ?v1)) ?v3 ?v4) (evaln$ (call$ ?v5 ?v0 ?v2) ?v1 ?v3 (update$ (setlocs$ ?v4 (getlocs$ ?v1)) ?v5 (getlocs$ ?v4 res$))))) :named a143))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 State_triple_option$)) (=> (and (= (= ?v0 none$a) (= ?v1 none$a)) (=> (and (not (= ?v0 none$a)) (not (= ?v1 none$a))) (= (the$a ?v0) (the$a ?v1)))) (= ?v0 ?v1))) :named a144))
+(assert (! (forall ((?v0 Com_option$) (?v1 Com_option$)) (=> (and (= (= ?v0 none$) (= ?v1 none$)) (=> (and (not (= ?v0 none$)) (not (= ?v1 none$))) (= (the$ ?v0) (the$ ?v1)))) (= ?v0 ?v1))) :named a145))
+(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (and (evaln$ (body$a ?v0) ?v1 ?v2 ?v3) (forall ((?v4 Nat$)) (=> (and (= ?v2 (suc$ ?v4)) (evaln$ (the$ (body$ ?v0)) ?v1 ?v4 ?v3)) false))) false)) :named a146))
+(assert (! (forall ((?v0 Pname$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (evaln$ (the$ (body$ ?v0)) ?v1 ?v2 ?v3) (evaln$ (body$a ?v0) ?v1 (suc$ ?v2) ?v3))) :named a147))
+(assert (! (forall ((?v0 State_triple_option$)) (=> (and (=> (= ?v0 none$a) false) (=> (not (= ?v0 none$a)) false)) false)) :named a148))
+(assert (! (forall ((?v0 Com_option$)) (=> (and (=> (= ?v0 none$) false) (=> (not (= ?v0 none$)) false)) false)) :named a149))
+(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$)) (=> (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v0 ?v1 (suc$ ?v2) ?v3))) :named a150))
+(assert (! (forall ((?v0 Pname$)) (=> (and (wt$ (body$a ?v0)) (forall ((?v1 Com$)) (=> (= (body$ ?v0) (some$ ?v1)) false))) false)) :named a151))
+(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool)) (?v2 Com_option$)) (! (= (case_option$ ?v0 ?v1 ?v2) (ite (= ?v2 none$) ?v0 (?v1 (the$ ?v2)))) :pattern ((case_option$ ?v0 ?v1 ?v2)))) :named a152))
+(assert (! (forall ((?v0 Glb$) (?v1 Glb$)) (= (= (glb$ ?v0) (glb$ ?v1)) (= ?v0 ?v1))) :named a153))
+(assert (! (forall ((?v0 State_triple_option$)) (= (not (= ?v0 none$a)) (exists ((?v1 State_triple$)) (= ?v0 (some$a ?v1))))) :named a154))
+(assert (! (forall ((?v0 Com_option$)) (= (not (= ?v0 none$)) (exists ((?v1 Com$)) (= ?v0 (some$ ?v1))))) :named a155))
+(assert (! (forall ((?v0 State_triple_option$)) (= (forall ((?v1 State_triple$)) (not (= ?v0 (some$a ?v1)))) (= ?v0 none$a))) :named a156))
+(assert (! (forall ((?v0 Com_option$)) (= (forall ((?v1 Com$)) (not (= ?v0 (some$ ?v1)))) (= ?v0 none$))) :named a157))
+(assert (! (forall ((?v0 State_triple_option$)) (=> (not (= ?v0 none$a)) (= (some$a (the$a ?v0)) ?v0))) :named a158))
+(assert (! (forall ((?v0 Com_option$)) (=> (not (= ?v0 none$)) (= (some$ (the$ ?v0)) ?v0))) :named a159))
+(assert (! (forall ((?v0 (-> Bool Bool)) (?v1 Bool) (?v2 (-> Com$ Bool)) (?v3 Com_option$)) (= (?v0 (case_option$ ?v1 ?v2 ?v3)) (and (=> (= ?v3 none$) (?v0 ?v1)) (=> (= ?v3 (some$ (the$ ?v3))) (?v0 (?v2 (the$ ?v3))))))) :named a160))
+(assert (! (forall ((?v0 (-> Bool Bool)) (?v1 Bool) (?v2 (-> Com$ Bool)) (?v3 Com_option$)) (= (?v0 (case_option$ ?v1 ?v2 ?v3)) (not (or (and (= ?v3 none$) (not (?v0 ?v1))) (and (= ?v3 (some$ (the$ ?v3))) (not (?v0 (?v2 (the$ ?v3))))))))) :named a161))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple_option$ (-> State_triple_option$ Bool))) (?v2 State_triple_option$)) (=> (and (=> (= ?v0 none$a) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$a) (?v1 ?v0 ?v2)) (forall ((?v3 State_triple$) (?v4 State_triple$)) (=> (and (= ?v0 (some$a ?v3)) (= ?v2 (some$a ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a162))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple_option$ (-> Com_option$ Bool))) (?v2 Com_option$)) (=> (and (=> (= ?v0 none$a) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$) (?v1 ?v0 ?v2)) (forall ((?v3 State_triple$) (?v4 Com$)) (=> (and (= ?v0 (some$a ?v3)) (= ?v2 (some$ ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a163))
+(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com_option$ (-> State_triple_option$ Bool))) (?v2 State_triple_option$)) (=> (and (=> (= ?v0 none$) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$a) (?v1 ?v0 ?v2)) (forall ((?v3 Com$) (?v4 State_triple$)) (=> (and (= ?v0 (some$ ?v3)) (= ?v2 (some$a ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a164))
+(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com_option$ (-> Com_option$ Bool))) (?v2 Com_option$)) (=> (and (=> (= ?v0 none$) (?v1 ?v0 ?v2)) (and (=> (= ?v2 none$) (?v1 ?v0 ?v2)) (forall ((?v3 Com$) (?v4 Com$)) (=> (and (= ?v0 (some$ ?v3)) (= ?v2 (some$ ?v4))) (?v1 ?v0 ?v2))))) (?v1 ?v0 ?v2))) :named a165))
+(assert (! (forall ((?v0 (-> State_triple_option$ Bool))) (= (forall ((?v1 State_triple_option$)) (?v0 ?v1)) (and (?v0 none$a) (forall ((?v1 State_triple$)) (?v0 (some$a ?v1)))))) :named a166))
+(assert (! (forall ((?v0 (-> Com_option$ Bool))) (= (forall ((?v1 Com_option$)) (?v0 ?v1)) (and (?v0 none$) (forall ((?v1 Com$)) (?v0 (some$ ?v1)))))) :named a167))
+(assert (! (forall ((?v0 (-> State_triple_option$ Bool))) (= (exists ((?v1 State_triple_option$)) (?v0 ?v1)) (or (?v0 none$a) (exists ((?v1 State_triple$)) (?v0 (some$a ?v1)))))) :named a168))
+(assert (! (forall ((?v0 (-> Com_option$ Bool))) (= (exists ((?v1 Com_option$)) (?v0 ?v1)) (or (?v0 none$) (exists ((?v1 Com$)) (?v0 (some$ ?v1)))))) :named a169))
+(assert (! (forall ((?v0 State_triple_option$)) (=> (and (=> (= ?v0 none$a) false) (forall ((?v1 State_triple$)) (=> (= ?v0 (some$a ?v1)) false))) false)) :named a170))
+(assert (! (forall ((?v0 Com_option$)) (=> (and (=> (= ?v0 none$) false) (forall ((?v1 Com$)) (=> (= ?v0 (some$ ?v1)) false))) false)) :named a171))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 State_triple$)) (=> (= ?v0 (some$a ?v1)) (not (= ?v0 none$a)))) :named a172))
+(assert (! (forall ((?v0 Com_option$) (?v1 Com$)) (=> (= ?v0 (some$ ?v1)) (not (= ?v0 none$)))) :named a173))
+(assert (! (forall ((?v0 State_triple$)) (not (= none$a (some$a ?v0)))) :named a174))
+(assert (! (forall ((?v0 Com$)) (not (= none$ (some$ ?v0)))) :named a175))
+(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool))) (! (= (case_option$ ?v0 ?v1 none$) ?v0) :pattern ((case_option$ ?v0 ?v1)))) :named a176))
+(assert (! (forall ((?v0 State_triple_option$)) (=> (and (=> (= ?v0 none$a) false) (=> (= ?v0 (some$a (the$a ?v0))) false)) false)) :named a177))
+(assert (! (forall ((?v0 Com_option$)) (=> (and (=> (= ?v0 none$) false) (=> (= ?v0 (some$ (the$ ?v0))) false)) false)) :named a178))
+(assert (! (forall ((?v0 Glb$) (?v1 Loc$)) (not (= (glb$ ?v0) (loc$ ?v1)))) :named a179))
+(assert (! (forall ((?v0 Vname$)) (=> (and (forall ((?v1 Glb$)) (=> (= ?v0 (glb$ ?v1)) false)) (forall ((?v1 Loc$)) (=> (= ?v0 (loc$ ?v1)) false))) false)) :named a180))
+(assert (! (forall ((?v0 Pname$) (?v1 Com$)) (=> (and wT_bodies$ (= (body$ ?v0) (some$ ?v1))) (wt$ ?v1))) :named a181))
+(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (= (triple_valid$ ?v0 (triple$ ?v1 (the$ (body$ ?v2)) ?v3)) (triple_valid$ (suc$ ?v0) (triple$ ?v1 (body$a ?v2) ?v3)))) :named a182))
+(assert (! (forall ((?v0 Pname_option$)) (=> (not (= ?v0 none$b)) (member$a (the$b ?v0) (set_option$ ?v0)))) :named a183))
+(assert (! (forall ((?v0 State_triple_option$)) (=> (not (= ?v0 none$a)) (member$ (the$a ?v0) (set_option$a ?v0)))) :named a184))
+(assert (! (forall ((?v0 Com_option$)) (=> (not (= ?v0 none$)) (member$b (the$ ?v0) (set_option$b ?v0)))) :named a185))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ Com_option$))) (= (= (bind$ ?v0 ?v1) none$) (or (= ?v0 none$a) (= (?v1 (the$a ?v0)) none$)))) :named a186))
+(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ State_triple_option$))) (= (= (bind$a ?v0 ?v1) none$a) (or (= ?v0 none$) (= (?v1 (the$ ?v0)) none$a)))) :named a187))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ State_triple_option$))) (= (= (bind$b ?v0 ?v1) none$a) (or (= ?v0 none$a) (= (?v1 (the$a ?v0)) none$a)))) :named a188))
+(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ Com_option$))) (= (= (bind$c ?v0 ?v1) none$) (or (= ?v0 none$) (= (?v1 (the$ ?v0)) none$)))) :named a189))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Com$) (?v2 (-> State$ (-> State$ Bool))) (?v3 (-> State$ (-> State$ Bool))) (?v4 Com$) (?v5 (-> State$ (-> State$ Bool)))) (= (= (triple$ ?v0 ?v1 ?v2) (triple$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5))))) :named a190))
+(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (= (triple_valid$ ?v0 (triple$ ?v1 ?v2 ?v3)) (forall ((?v4 State$) (?v5 State$)) (=> (?v1 ?v4 ?v5) (forall ((?v6 State$)) (=> (evaln$ ?v2 ?v5 ?v0 ?v6) (?v3 ?v4 ?v6))))))) :named a191))
+(assert (! (forall ((?v0 State_triple$)) (=> (forall ((?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (= ?v0 (triple$ ?v1 ?v2 ?v3)) false)) false)) :named a192))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$))) (! (= (bind$a none$ ?v0) none$a) :pattern ((bind$a none$ ?v0)))) :named a193))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (! (= (bind$ none$a ?v0) none$) :pattern ((bind$ none$a ?v0)))) :named a194))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$))) (! (= (bind$b none$a ?v0) none$a) :pattern ((bind$b none$a ?v0)))) :named a195))
+(assert (! (forall ((?v0 (-> Com$ Com_option$))) (! (= (bind$c none$ ?v0) none$) :pattern ((bind$c none$ ?v0)))) :named a196))
+(assert (! (forall ((?v0 Nat$) (?v1 State_triple$)) (=> (triple_valid$ (suc$ ?v0) ?v1) (triple_valid$ ?v0 ?v1))) :named a197))
+(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ Com_option$))) (= (?v0 (bind$ ?v1 ?v2)) (and (=> (= ?v1 none$a) (?v0 none$)) (forall ((?v3 State_triple$)) (=> (= ?v1 (some$a ?v3)) (?v0 (?v2 ?v3))))))) :named a198))
+(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ State_triple_option$))) (= (?v0 (bind$b ?v1 ?v2)) (and (=> (= ?v1 none$a) (?v0 none$a)) (forall ((?v3 State_triple$)) (=> (= ?v1 (some$a ?v3)) (?v0 (?v2 ?v3))))))) :named a199))
+(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ State_triple_option$))) (= (?v0 (bind$a ?v1 ?v2)) (and (=> (= ?v1 none$) (?v0 none$a)) (forall ((?v3 Com$)) (=> (= ?v1 (some$ ?v3)) (?v0 (?v2 ?v3))))))) :named a200))
+(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ Com_option$))) (= (?v0 (bind$c ?v1 ?v2)) (and (=> (= ?v1 none$) (?v0 none$)) (forall ((?v3 Com$)) (=> (= ?v1 (some$ ?v3)) (?v0 (?v2 ?v3))))))) :named a201))
+(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ Com_option$))) (= (?v0 (bind$ ?v1 ?v2)) (not (or (and (= ?v1 none$a) (not (?v0 none$))) (exists ((?v3 State_triple$)) (and (= ?v1 (some$a ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a202))
+(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 State_triple_option$) (?v2 (-> State_triple$ State_triple_option$))) (= (?v0 (bind$b ?v1 ?v2)) (not (or (and (= ?v1 none$a) (not (?v0 none$a))) (exists ((?v3 State_triple$)) (and (= ?v1 (some$a ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a203))
+(assert (! (forall ((?v0 (-> State_triple_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ State_triple_option$))) (= (?v0 (bind$a ?v1 ?v2)) (not (or (and (= ?v1 none$) (not (?v0 none$a))) (exists ((?v3 Com$)) (and (= ?v1 (some$ ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a204))
+(assert (! (forall ((?v0 (-> Com_option$ Bool)) (?v1 Com_option$) (?v2 (-> Com$ Com_option$))) (= (?v0 (bind$c ?v1 ?v2)) (not (or (and (= ?v1 none$) (not (?v0 none$))) (exists ((?v3 Com$)) (and (= ?v1 (some$ ?v3)) (not (?v0 (?v2 ?v3))))))))) :named a205))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Pname$) (?v2 (-> State$ (-> State$ Bool)))) (triple_valid$ zero$ (triple$ ?v0 (body$a ?v1) ?v2))) :named a206))
+(assert (! (forall ((?v0 Pname_option$)) (= (= (set_option$ ?v0) bot$) (= ?v0 none$b))) :named a207))
+(assert (! (forall ((?v0 State_triple_option_option$)) (= (= (set_option$c ?v0) bot$a) (= ?v0 none$c))) :named a208))
+(assert (! (forall ((?v0 Com_option_option$)) (= (= (set_option$d ?v0) bot$b) (= ?v0 none$d))) :named a209))
+(assert (! (forall ((?v0 Com_option$)) (= (= (set_option$b ?v0) bot$c) (= ?v0 none$))) :named a210))
+(assert (! (forall ((?v0 State_triple_option$)) (= (= (set_option$a ?v0) bot$d) (= ?v0 none$a))) :named a211))
+(assert (! (= (set_option$ none$b) bot$) :named a212))
+(assert (! (= (set_option$c none$c) bot$a) :named a213))
+(assert (! (= (set_option$d none$d) bot$b) :named a214))
+(assert (! (= (set_option$b none$) bot$c) :named a215))
+(assert (! (= (set_option$a none$a) bot$d) :named a216))
+(assert (! (forall ((?v0 (-> State$ Nat$)) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (! (= (size_triple$ ?v0 (triple$ ?v1 ?v2 ?v3)) (suc$ zero$)) :pattern ((size_triple$ ?v0 (triple$ ?v1 ?v2 ?v3))))) :named a217))
+(assert (! (forall ((?v0 Glb$)) (! (= (size_vname$ (glb$ ?v0)) zero$) :pattern ((glb$ ?v0)))) :named a218))
+(assert (! (forall ((?v0 Loc$)) (! (= (size_vname$ (loc$ ?v0)) zero$) :pattern ((loc$ ?v0)))) :named a219))
+(assert (! (forall ((?v0 (-> State_triple$ Nat$))) (! (= (size_option$ ?v0 none$a) (suc$ zero$)) :pattern ((size_option$ ?v0)))) :named a220))
+(assert (! (forall ((?v0 (-> Com$ Nat$))) (! (= (size_option$a ?v0 none$) (suc$ zero$)) :pattern ((size_option$a ?v0)))) :named a221))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Com$) (?v2 (-> State$ (-> State$ Bool)))) (! (= (size$ (triple$ ?v0 ?v1 ?v2)) (suc$ zero$)) :pattern ((triple$ ?v0 ?v1 ?v2)))) :named a222))
+(assert (! (= (size$a none$a) (suc$ zero$)) :named a223))
+(assert (! (= (size$b none$) (suc$ zero$)) :named a224))
+(assert (! (forall ((?v0 State_triple$)) (not (= (size$ ?v0) zero$))) :named a225))
+(assert (! (forall ((?v0 Glb$)) (! (= (size$c (glb$ ?v0)) zero$) :pattern ((glb$ ?v0)))) :named a226))
+(assert (! (forall ((?v0 Loc$)) (! (= (size$c (loc$ ?v0)) zero$) :pattern ((loc$ ?v0)))) :named a227))
+(assert (! (= (size_com$ skip$) zero$) :named a228))
+(assert (! (forall ((?v0 Pname$)) (! (= (size_com$ (body$a ?v0)) zero$) :pattern ((body$a ?v0)))) :named a229))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (! (= (size_com$ (call$ ?v0 ?v1 ?v2)) zero$) :pattern ((call$ ?v0 ?v1 ?v2)))) :named a230))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (! (= (size_com$ (ass$ ?v0 ?v1)) zero$) :pattern ((ass$ ?v0 ?v1)))) :named a231))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (! (= (size_com$ (local$ ?v0 ?v1 ?v2)) (plus$ (size_com$ ?v2) (suc$ zero$))) :pattern ((local$ ?v0 ?v1 ?v2)))) :named a232))
+(assert (! (forall ((?v0 Com$) (?v1 Com$)) (! (= (size_com$ (semi$ ?v0 ?v1)) (plus$ (plus$ (size_com$ ?v0) (size_com$ ?v1)) (suc$ zero$))) :pattern ((semi$ ?v0 ?v1)))) :named a233))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (! (= (size_com$ (cond$ ?v0 ?v1 ?v2)) (plus$ (plus$ (size_com$ ?v1) (size_com$ ?v2)) (suc$ zero$))) :pattern ((cond$ ?v0 ?v1 ?v2)))) :named a234))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (! (= (size_com$ (while$ ?v0 ?v1)) (plus$ (size_com$ ?v1) (suc$ zero$))) :pattern ((while$ ?v0 ?v1)))) :named a235))
+(assert (! (forall ((?v0 Loc$) (?v1 (-> State$ Nat$)) (?v2 Com$)) (! (= (size$d (local$ ?v0 ?v1 ?v2)) (plus$ (size$d ?v2) (suc$ zero$))) :pattern ((local$ ?v0 ?v1 ?v2)))) :named a236))
+(assert (! (forall ((?v0 Com$) (?v1 Com$)) (! (= (size$d (semi$ ?v0 ?v1)) (plus$ (plus$ (size$d ?v0) (size$d ?v1)) (suc$ zero$))) :pattern ((semi$ ?v0 ?v1)))) :named a237))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$) (?v2 Com$)) (! (= (size$d (cond$ ?v0 ?v1 ?v2)) (plus$ (plus$ (size$d ?v1) (size$d ?v2)) (suc$ zero$))) :pattern ((cond$ ?v0 ?v1 ?v2)))) :named a238))
+(assert (! (forall ((?v0 Pname$)) (! (= (size$d (body$a ?v0)) zero$) :pattern ((body$a ?v0)))) :named a239))
+(assert (! (forall ((?v0 Vname$) (?v1 Pname$) (?v2 (-> State$ Nat$))) (! (= (size$d (call$ ?v0 ?v1 ?v2)) zero$) :pattern ((call$ ?v0 ?v1 ?v2)))) :named a240))
+(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (! (= (size$d (ass$ ?v0 ?v1)) zero$) :pattern ((ass$ ?v0 ?v1)))) :named a241))
+(assert (! (= (size$d skip$) zero$) :named a242))
+(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (! (= (size$d (while$ ?v0 ?v1)) (plus$ (size$d ?v1) (suc$ zero$))) :pattern ((while$ ?v0 ?v1)))) :named a243))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool))) (?v4 State$) (?v5 Vname$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (body$a ?v2) (uuc$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uud$ ?v1 ?v4 ?v6) (call$ ?v5 ?v2 ?v6) ?v3) bot$d)))) :named a244))
+(assert (! (forall ((?v0 Com_option$)) (= (bind$c ?v0 uue$) none$)) :named a245))
+(assert (! (forall ((?v0 Bool) (?v1 (-> State_triple$ Bool)) (?v2 State_triple_option$)) (=> (and (case_option$a ?v0 ?v1 ?v2) (and (=> (and (= ?v2 none$a) ?v0) false) (forall ((?v3 State_triple$)) (=> (and (= ?v2 (some$a ?v3)) (?v1 ?v3)) false)))) false)) :named a246))
+(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool)) (?v2 Com_option$)) (=> (and (case_option$ ?v0 ?v1 ?v2) (and (=> (and (= ?v2 none$) ?v0) false) (forall ((?v3 Com$)) (=> (and (= ?v2 (some$ ?v3)) (?v1 ?v3)) false)))) false)) :named a247))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple_set$) (?v2 State_triple_set$)) (=> (and (hoare_derivs$ ?v0 ?v1) (hoare_derivs$ ?v2 ?v0)) (hoare_derivs$ ?v2 ?v1))) :named a248))
+(assert (! (forall ((?v0 State_triple_option$)) (= (not (= ?v0 none$a)) (case_option$a false uuf$ ?v0))) :named a249))
+(assert (! (forall ((?v0 Com_option$)) (= (not (= ?v0 none$)) (case_option$ false uug$ ?v0))) :named a250))
+(assert (! (forall ((?v0 State_triple_option$)) (= (= ?v0 none$a) (case_option$a true uuh$ ?v0))) :named a251))
+(assert (! (forall ((?v0 Com_option$)) (= (= ?v0 none$) (case_option$ true uui$ ?v0))) :named a252))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (hoare_derivs$ ?v0 (insert$ ?v1 ?v2)) (and (hoare_derivs$ ?v0 (insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)))) :named a253))
+(assert (! (forall ((?v0 State_triple_set$)) (hoare_derivs$ ?v0 bot$d)) :named a254))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (and (hoare_derivs$ ?v0 (insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)) (hoare_derivs$ ?v0 (insert$ ?v1 ?v2)))) :named a255))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Loc$) (?v5 State$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 (uuj$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uuk$ ?v1 ?v4 ?v5 ?v6) (local$ ?v4 ?v6 ?v2) ?v3) bot$d)))) :named a256))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (hoare_derivs$ ?v0 (insert$ (triple$ (uul$ ?v1 ?v2) (while$ ?v2 ?v3) ?v1) bot$d))) :named a257))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Com$) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v3 ?v4 ?v5) bot$d))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (semi$ ?v2 ?v4) ?v5) bot$d)))) :named a258))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 skip$ ?v1) bot$d))) :named a259))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (exists ((?v6 (-> State$ (-> State$ Bool))) (?v7 (-> State$ (-> State$ Bool)))) (and (hoare_derivs$ ?v1 (insert$ (triple$ ?v6 ?v2 ?v7) bot$d)) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v6 ?v9 ?v5) (?v7 ?v9 ?v8))) (?v3 ?v4 ?v8))))))) (hoare_derivs$ ?v1 (insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a260))
+(assert (! (forall ((?v0 Bool) (?v1 State_triple_set$) (?v2 (-> State$ (-> State$ Bool))) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool)))) (=> (=> ?v0 (hoare_derivs$ ?v1 (insert$ (triple$ ?v2 ?v3 ?v4) bot$d))) (hoare_derivs$ ?v1 (insert$ (triple$ (uum$ ?v0 ?v2) ?v3 ?v4) bot$d)))) :named a261))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool))) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v6 State$) (?v7 State$)) (=> (?v4 ?v6 ?v7) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v1 ?v9 ?v7) (?v3 ?v9 ?v8))) (?v5 ?v6 ?v8)))))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v4 ?v2 ?v5) bot$d)))) :named a262))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v3 ?v5 ?v6) (?v4 ?v5 ?v6)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v4) bot$d)))) :named a263))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v4 ?v5 ?v6) (?v1 ?v5 ?v6)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v4 ?v2 ?v3) bot$d)))) :named a264))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (hoare_derivs$ ?v1 (insert$ (triple$ (uun$ ?v5) ?v2 (uuo$ ?v3 ?v4)) bot$d)))) (hoare_derivs$ ?v1 (insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a265))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Vname$) (?v3 (-> State$ Nat$))) (hoare_derivs$ ?v0 (insert$ (triple$ (uup$ ?v1 ?v2 ?v3) (ass$ ?v2 ?v3) ?v1) bot$d))) :named a266))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Pname$) (?v2 (-> State$ (-> State$ Bool))) (?v3 State_triple_set$)) (=> (hoare_derivs$ (insert$ (triple$ ?v0 (body$a ?v1) ?v2) ?v3) (insert$ (triple$ ?v0 (the$ (body$ ?v1)) ?v2) bot$d)) (hoare_derivs$ ?v3 (insert$ (triple$ ?v0 (body$a ?v1) ?v2) bot$d)))) :named a267))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (the$ (body$ ?v2)) ?v3) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (body$a ?v2) ?v3) bot$d)))) :named a268))
+(assert (! (forall ((?v0 Com$)) (! (= (mgt$ ?v0) (triple$ uuq$ ?v0 (evalc$ ?v0))) :pattern ((mgt$ ?v0)))) :named a269))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$) (?v4 Pname$)) (=> (and (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (member$a ?v4 ?v3)) (hoare_derivs$ ?v0 (insert$ (triple$ (?v1 ?v4) (body$a ?v4) (?v2 ?v4)) bot$d)))) :named a270))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool))) (?v5 Com$)) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v4) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 (comp$ uut$ ?v2)) ?v5 ?v4) bot$d))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (cond$ ?v2 ?v3 ?v5) ?v4) bot$d)))) :named a271))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 (-> State$ Bool)) (?v2 State$) (?v3 State$)) (! (= (peek_and$ ?v0 ?v1 ?v2 ?v3) (and (?v0 ?v2 ?v3) (?v1 ?v3))) :pattern ((peek_and$ ?v0 ?v1 ?v2 ?v3)))) :named a272))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$)) (=> (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (hoare_derivs$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)))) :named a273))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a274))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$)) (=> (hoare_valids$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (hoare_valids$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)))) :named a275))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_valids$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_valids$ ?v0 (insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a276))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple_set$)) (=> (hoare_derivs$ ?v0 ?v1) (hoare_valids$ ?v0 ?v1))) :named a277))
+(assert (! (forall ((?v0 Pname_set$) (?v1 State_triple_set$) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 (-> Pname$ Com$)) (?v4 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v5 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v6 (-> Pname$ (-> State$ (-> State$ Bool))))) (=> (and (finite$ ?v0) (and (forall ((?v7 Pname$)) (=> (hoare_derivs$ ?v1 (insert$ (triple$ (?v2 ?v7) (?v3 ?v7) (?v4 ?v7)) bot$d)) (hoare_derivs$ ?v1 (insert$ (triple$ (?v5 ?v7) (?v3 ?v7) (?v6 ?v7)) bot$d)))) (hoare_derivs$ ?v1 (image$ (uuu$ ?v2 ?v3 ?v4) ?v0)))) (hoare_derivs$ ?v1 (image$ (uuv$ ?v3 ?v5 ?v6) ?v0)))) :named a278))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 Com$)) (=> (hoare_derivs$ ?v0 (insert$ (mgt$ ?v1) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uuw$ ?v1) ?v1 uuq$) bot$d)))) :named a279))
+(assert (! (forall ((?v0 Nat$) (?v1 State_triple$)) (= (triple_valid$ ?v0 ?v1) (case_triple$ (uux$ ?v0) ?v1))) :named a280))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$ (fun_upd$ ?v0 ?v1 (some$ ?v2))) (insert$a ?v2 (ran$ ?v0))))) :named a281))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$a (fun_upd$a ?v0 ?v1 (some$ ?v2))) (insert$a ?v2 (ran$a ?v0))))) :named a282))
+(assert (! (forall ((?v0 State_triple$) (?v1 State_triple$)) (= (fun_upd$ uuy$ ?v0 none$ ?v1) none$)) :named a283))
+(assert (! (forall ((?v0 Pname$) (?v1 Pname$)) (= (fun_upd$a uuz$ ?v0 none$ ?v1) none$)) :named a284))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (not (= (fun_upd$ ?v0 ?v1 (some$ ?v2)) uuy$))) :named a285))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (not (= (fun_upd$a ?v0 ?v1 (some$ ?v2)) uuz$))) :named a286))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$)) (= (= (dom$ ?v0) (insert$ ?v1 bot$d)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$b uva$ ?v1 (some$a ?v2)))))) :named a287))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$)) (= (= (dom$a ?v0) (insert$a ?v1 bot$c)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$c uvb$ ?v1 (some$a ?v2)))))) :named a288))
+(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$)) (= (= (dom$b ?v0) (insert$a ?v1 bot$c)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$d uue$ ?v1 (some$ ?v2)))))) :named a289))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (= (= (dom$c ?v0) (insert$b ?v1 bot$)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$e uvc$ ?v1 (some$a ?v2)))))) :named a290))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$)) (= (= (dom$d ?v0) (insert$c ?v1 bot$a)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$f uvd$ ?v1 (some$a ?v2)))))) :named a291))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$)) (= (= (dom$e ?v0) (insert$c ?v1 bot$a)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$g uve$ ?v1 (some$ ?v2)))))) :named a292))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (= (dom$f ?v0) (insert$d ?v1 bot$b)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$h uvf$ ?v1 (some$a ?v2)))))) :named a293))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (= (dom$g ?v0) (insert$d ?v1 bot$b)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$i uvg$ ?v1 (some$ ?v2)))))) :named a294))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (= (= (dom$h ?v0) (insert$b ?v1 bot$)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$a uuz$ ?v1 (some$ ?v2)))))) :named a295))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (= (dom$i ?v0) (insert$ ?v1 bot$d)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$ uuy$ ?v1 (some$ ?v2)))))) :named a296))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 (-> State_triple$ Com_option$)) (?v2 State_triple$) (?v3 Com$)) (=> (map_le$ ?v0 ?v1) (map_le$ (fun_upd$ ?v0 ?v2 none$) (fun_upd$ ?v1 ?v2 (some$ ?v3))))) :named a297))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 (-> Pname$ Com_option$)) (?v2 Pname$) (?v3 Com$)) (=> (map_le$a ?v0 ?v1) (map_le$a (fun_upd$a ?v0 ?v2 none$) (fun_upd$a ?v1 ?v2 (some$ ?v3))))) :named a298))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$))) (= (= (dom$ ?v0) bot$d) (= ?v0 uva$))) :named a299))
+(assert (! (forall ((?v0 (-> Com$ Com_option$))) (= (= (dom$b ?v0) bot$c) (= ?v0 uue$))) :named a300))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$))) (= (= (dom$a ?v0) bot$c) (= ?v0 uvb$))) :named a301))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$))) (= (= (dom$c ?v0) bot$) (= ?v0 uvc$))) :named a302))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$))) (= (= (dom$e ?v0) bot$a) (= ?v0 uve$))) :named a303))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$))) (= (= (dom$d ?v0) bot$a) (= ?v0 uvd$))) :named a304))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$))) (= (= (dom$g ?v0) bot$b) (= ?v0 uvg$))) :named a305))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$))) (= (= (dom$f ?v0) bot$b) (= ?v0 uvf$))) :named a306))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$))) (= (= (dom$h ?v0) bot$) (= ?v0 uuz$))) :named a307))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (= (= (dom$i ?v0) bot$d) (= ?v0 uuy$))) :named a308))
+(assert (! (= (dom$ uva$) bot$d) :named a309))
+(assert (! (= (dom$b uue$) bot$c) :named a310))
+(assert (! (= (dom$a uvb$) bot$c) :named a311))
+(assert (! (= (dom$c uvc$) bot$) :named a312))
+(assert (! (= (dom$e uve$) bot$a) :named a313))
+(assert (! (= (dom$d uvd$) bot$a) :named a314))
+(assert (! (= (dom$g uvg$) bot$b) :named a315))
+(assert (! (= (dom$f uvf$) bot$b) :named a316))
+(assert (! (= (dom$h uuz$) bot$) :named a317))
+(assert (! (= (dom$i uuy$) bot$d) :named a318))
+(assert (! (finite$ (dom$h body$)) :named a319))
+(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Com_option$))) (= (member$b ?v0 (dom$b ?v1)) (not (= (?v1 ?v0) none$)))) :named a320))
+(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Com_option$))) (= (member$ ?v0 (dom$i ?v1)) (not (= (?v1 ?v0) none$)))) :named a321))
+(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ State_triple_option$))) (= (member$b ?v0 (dom$a ?v1)) (not (= (?v1 ?v0) none$a)))) :named a322))
+(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ State_triple_option$))) (= (member$a ?v0 (dom$c ?v1)) (not (= (?v1 ?v0) none$a)))) :named a323))
+(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ State_triple_option$))) (= (member$ ?v0 (dom$ ?v1)) (not (= (?v1 ?v0) none$a)))) :named a324))
+(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Com_option$))) (= (member$a ?v0 (dom$h ?v1)) (not (= (?v1 ?v0) none$)))) :named a325))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (= (dom$i ?v0) (collect$a (uvh$ ?v0)))) :named a326))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$))) (= (dom$c ?v0) (collect$b (uvi$ ?v0)))) :named a327))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$))) (= (dom$h ?v0) (collect$b (uvj$ ?v0)))) :named a328))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (map_le$ (fun_upd$ ?v0 ?v1 none$) ?v0)) :named a329))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (map_le$a (fun_upd$a ?v0 ?v1 none$) ?v0)) :named a330))
+(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$) (?v2 Com_option$)) (= (dom$b (fun_upd$d ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$ (dom$b ?v0) (insert$a ?v1 bot$c)) (insert$a ?v1 (dom$b ?v0))))) :named a331))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$) (?v2 State_triple_option$)) (= (dom$a (fun_upd$c ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$ (dom$a ?v0) (insert$a ?v1 bot$c)) (insert$a ?v1 (dom$a ?v0))))) :named a332))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 Com_option$)) (= (dom$e (fun_upd$g ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$a (dom$e ?v0) (insert$c ?v1 bot$a)) (insert$c ?v1 (dom$e ?v0))))) :named a333))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option$)) (= (dom$d (fun_upd$f ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$a (dom$d ?v0) (insert$c ?v1 bot$a)) (insert$c ?v1 (dom$d ?v0))))) :named a334))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option$)) (= (dom$g (fun_upd$i ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$b (dom$g ?v0) (insert$d ?v1 bot$b)) (insert$d ?v1 (dom$g ?v0))))) :named a335))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 State_triple_option$)) (= (dom$f (fun_upd$h ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$b (dom$f ?v0) (insert$d ?v1 bot$b)) (insert$d ?v1 (dom$f ?v0))))) :named a336))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_option$)) (= (dom$ (fun_upd$b ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$c (dom$ ?v0) (insert$ ?v1 bot$d)) (insert$ ?v1 (dom$ ?v0))))) :named a337))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 State_triple_option$)) (= (dom$c (fun_upd$e ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$d (dom$c ?v0) (insert$b ?v1 bot$)) (insert$b ?v1 (dom$c ?v0))))) :named a338))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com_option$)) (= (dom$h (fun_upd$a ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$d (dom$h ?v0) (insert$b ?v1 bot$)) (insert$b ?v1 (dom$h ?v0))))) :named a339))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com_option$)) (= (dom$i (fun_upd$ ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$c (dom$i ?v0) (insert$ ?v1 bot$d)) (insert$ ?v1 (dom$i ?v0))))) :named a340))
+(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (map_option$ ?v0 ?v1) (case_option$b none$ (uvk$ ?v0) ?v1))) :named a341))
+(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= (map_option$a ?v0 ?v1) none$) (= ?v1 none$a))) :named a342))
+(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= (map_option$b ?v0 ?v1) none$a) (= ?v1 none$))) :named a343))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple$)) (?v1 State_triple_option$)) (= (= (map_option$c ?v0 ?v1) none$a) (= ?v1 none$a))) :named a344))
+(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (= (map_option$ ?v0 ?v1) none$) (= ?v1 none$))) :named a345))
+(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= (map_option$a ?v0 ?v1) none$) (= ?v1 none$a))) :named a346))
+(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= (map_option$b ?v0 ?v1) none$a) (= ?v1 none$))) :named a347))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple$)) (?v1 State_triple_option$)) (= (= (map_option$c ?v0 ?v1) none$a) (= ?v1 none$a))) :named a348))
+(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (= (map_option$ ?v0 ?v1) none$) (= ?v1 none$))) :named a349))
+(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= none$ (map_option$a ?v0 ?v1)) (= ?v1 none$a))) :named a350))
+(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= none$a (map_option$b ?v0 ?v1)) (= ?v1 none$))) :named a351))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple$)) (?v1 State_triple_option$)) (= (= none$a (map_option$c ?v0 ?v1)) (= ?v1 none$a))) :named a352))
+(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (= none$ (map_option$ ?v0 ?v1)) (= ?v1 none$))) :named a353))
+(assert (! (forall ((?v0 (-> Com$ State_triple$))) (! (= (map_option$b ?v0 none$) none$a) :pattern ((map_option$b ?v0)))) :named a354))
+(assert (! (forall ((?v0 (-> State_triple$ Com$))) (! (= (map_option$a ?v0 none$a) none$) :pattern ((map_option$a ?v0)))) :named a355))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple$))) (! (= (map_option$c ?v0 none$a) none$a) :pattern ((map_option$c ?v0)))) :named a356))
+(assert (! (forall ((?v0 (-> Com$ Com$))) (! (= (map_option$ ?v0 none$) none$) :pattern ((map_option$ ?v0)))) :named a357))
+(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ Com$))) (=> (not (= ?v0 none$a)) (= (the$ (map_option$a ?v1 ?v0)) (?v1 (the$a ?v0))))) :named a358))
+(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ Com$))) (=> (not (= ?v0 none$)) (= (the$ (map_option$ ?v1 ?v0)) (?v1 (the$ ?v0))))) :named a359))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$a (dom$e ?v0) (insert$c ?v1 ?v2)) (minus$a (dom$e ?v0) ?v2)))) :named a360))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$b (dom$g ?v0) (insert$d ?v1 ?v2)) (minus$b (dom$g ?v0) ?v2)))) :named a361))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$a (dom$d ?v0) (insert$c ?v1 ?v2)) (minus$a (dom$d ?v0) ?v2)))) :named a362))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$b (dom$f ?v0) (insert$d ?v1 ?v2)) (minus$b (dom$f ?v0) ?v2)))) :named a363))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$c (dom$ ?v0) (insert$ ?v1 ?v2)) (minus$c (dom$ ?v0) ?v2)))) :named a364))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$d (dom$c ?v0) (insert$b ?v1 ?v2)) (minus$d (dom$c ?v0) ?v2)))) :named a365))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$) (= (minus$d (dom$h ?v0) (insert$b ?v1 ?v2)) (minus$d (dom$h ?v0) ?v2)))) :named a366))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$) (= (minus$c (dom$i ?v0) (insert$ ?v1 ?v2)) (minus$c (dom$i ?v0) ?v2)))) :named a367))
+(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$d (restrict_map$ ?v0 ?v1) ?v2 none$) (ite (member$b ?v2 ?v1) (restrict_map$ ?v0 (minus$ ?v1 (insert$a ?v2 bot$c))) (restrict_map$ ?v0 ?v1)))) :named a368))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$c (restrict_map$a ?v0 ?v1) ?v2 none$a) (ite (member$b ?v2 ?v1) (restrict_map$a ?v0 (minus$ ?v1 (insert$a ?v2 bot$c))) (restrict_map$a ?v0 ?v1)))) :named a369))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$g (restrict_map$b ?v0 ?v1) ?v2 none$) (ite (member$c ?v2 ?v1) (restrict_map$b ?v0 (minus$a ?v1 (insert$c ?v2 bot$a))) (restrict_map$b ?v0 ?v1)))) :named a370))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$f (restrict_map$c ?v0 ?v1) ?v2 none$a) (ite (member$c ?v2 ?v1) (restrict_map$c ?v0 (minus$a ?v1 (insert$c ?v2 bot$a))) (restrict_map$c ?v0 ?v1)))) :named a371))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$i (restrict_map$d ?v0 ?v1) ?v2 none$) (ite (member$d ?v2 ?v1) (restrict_map$d ?v0 (minus$b ?v1 (insert$d ?v2 bot$b))) (restrict_map$d ?v0 ?v1)))) :named a372))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$h (restrict_map$e ?v0 ?v1) ?v2 none$a) (ite (member$d ?v2 ?v1) (restrict_map$e ?v0 (minus$b ?v1 (insert$d ?v2 bot$b))) (restrict_map$e ?v0 ?v1)))) :named a373))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$b (restrict_map$f ?v0 ?v1) ?v2 none$a) (ite (member$ ?v2 ?v1) (restrict_map$f ?v0 (minus$c ?v1 (insert$ ?v2 bot$d))) (restrict_map$f ?v0 ?v1)))) :named a374))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$a (restrict_map$g ?v0 ?v1) ?v2 none$) (ite (member$a ?v2 ?v1) (restrict_map$g ?v0 (minus$d ?v1 (insert$b ?v2 bot$))) (restrict_map$g ?v0 ?v1)))) :named a375))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$e (restrict_map$h ?v0 ?v1) ?v2 none$a) (ite (member$a ?v2 ?v1) (restrict_map$h ?v0 (minus$d ?v1 (insert$b ?v2 bot$))) (restrict_map$h ?v0 ?v1)))) :named a376))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$ (restrict_map$i ?v0 ?v1) ?v2 none$) (ite (member$ ?v2 ?v1) (restrict_map$i ?v0 (minus$c ?v1 (insert$ ?v2 bot$d))) (restrict_map$i ?v0 ?v1)))) :named a377))
+(assert (! (forall ((?v0 Pname_option_set$)) (= (not (= (these$ ?v0) bot$)) (and (not (= ?v0 bot$e)) (not (= ?v0 (insert$e none$b bot$e)))))) :named a378))
+(assert (! (forall ((?v0 State_triple_option_option_set$)) (= (not (= (these$a ?v0) bot$a)) (and (not (= ?v0 bot$f)) (not (= ?v0 (insert$f none$c bot$f)))))) :named a379))
+(assert (! (forall ((?v0 Com_option_option_set$)) (= (not (= (these$b ?v0) bot$b)) (and (not (= ?v0 bot$g)) (not (= ?v0 (insert$g none$d bot$g)))))) :named a380))
+(assert (! (forall ((?v0 Com_option_set$)) (= (not (= (these$c ?v0) bot$c)) (and (not (= ?v0 bot$b)) (not (= ?v0 (insert$d none$ bot$b)))))) :named a381))
+(assert (! (forall ((?v0 State_triple_option_set$)) (= (not (= (these$d ?v0) bot$d)) (and (not (= ?v0 bot$a)) (not (= ?v0 (insert$c none$a bot$a)))))) :named a382))
+(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ Com_option$))) (! (=> (not (member$b ?v0 ?v1)) (= (restrict_map$ ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$ ?v2 ?v1 ?v0)))) :named a383))
+(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ Com_option$))) (! (=> (not (member$a ?v0 ?v1)) (= (restrict_map$g ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$g ?v2 ?v1 ?v0)))) :named a384))
+(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ Com_option$))) (! (=> (not (member$ ?v0 ?v1)) (= (restrict_map$i ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$i ?v2 ?v1 ?v0)))) :named a385))
+(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ State_triple_option$))) (! (=> (not (member$b ?v0 ?v1)) (= (restrict_map$a ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$a ?v2 ?v1 ?v0)))) :named a386))
+(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ State_triple_option$))) (! (=> (not (member$a ?v0 ?v1)) (= (restrict_map$h ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$h ?v2 ?v1 ?v0)))) :named a387))
+(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ State_triple_option$))) (! (=> (not (member$ ?v0 ?v1)) (= (restrict_map$f ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$f ?v2 ?v1 ?v0)))) :named a388))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (= (restrict_map$i uuy$ ?v0 ?v1) none$)) :named a389))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (restrict_map$d ?v0 bot$b ?v1) none$)) :named a390))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (restrict_map$e ?v0 bot$b ?v1) none$a)) :named a391))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 bot$d ?v1) none$)) :named a392))
+(assert (! (forall ((?v0 Com_option_set$)) (= (these$c (insert$d none$ ?v0)) (these$c ?v0))) :named a393))
+(assert (! (forall ((?v0 Com_option_set$)) (= (= (these$c ?v0) bot$c) (or (= ?v0 bot$b) (= ?v0 (insert$d none$ bot$b))))) :named a394))
+(assert (! (forall ((?v0 State_triple_option_set$)) (= (= (these$d ?v0) bot$d) (or (= ?v0 bot$a) (= ?v0 (insert$c none$a bot$a))))) :named a395))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 (uminus$ (insert$ ?v1 bot$d))) (fun_upd$ ?v0 ?v1 none$))) :named a396))
+(check-sat)
+;(get-proof)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic UFLIA)
+(set-info :status sat)
+(declare-fun x () Int)
+(declare-fun f (Int) Int)
+(declare-fun g (Int) Int)
+(declare-fun h (Int) Int)
+
+(assert (= h (ite (> x 0) f g)))
+
+(assert (= (h 4) 5))
+
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: sat
+(set-logic ALL)
+(set-info :status sat)
+(declare-fun f (Int) Int)
+
+(assert (= f (lambda ((x Int)) (ite (and true (= x 0)) 1 2))))
+
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic UFLIA)
+(set-info :status unsat)
+(declare-fun P (Int) Bool)
+(declare-fun Q (Int) Bool)
+(declare-fun R (Int) Bool)
+
+(assert (or (= P Q) (= P R)))
+
+(assert (not (Q 0)))
+(assert (not (R 3)))
+
+(assert (forall ((x Int)) (P x)))
+
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+(declare-sort U 0)
+(declare-fun f (U U) U)
+(declare-fun g (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(declare-fun c () U)
+; should instantiate f/x, g/y
+(assert (forall ((x (-> U U U)) (y (-> U U))) (=> (not (= (x a) y)) (or (= (x a c) b) (= (y c) b)))))
+(assert (not (= (f a c) b)))
+(assert (not (= (g c) b)))
+; this is required for unsatisfiable or else (f a) can be equal to g
+(assert (not (= (f a a) (g a))))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic ALL)
+(set-info :status unsat)
+(declare-sort U 0)
+(declare-fun f (U) U)
+(declare-fun a () U)
+(declare-fun b () U)
+(assert (forall ((x (-> U U))) (= (x a) b)))
+(assert (not (= (f a) b)))
+(check-sat)
--- /dev/null
+; COMMAND-LINE: --uf-ho
+; EXPECT: unsat
+(set-logic UF)
+(set-info :status unsat)
+(declare-sort U 0)
+(declare-fun f (U) U)
+(declare-fun g (U) U)
+(declare-fun h (U) U)
+(declare-fun a () U)
+(assert (= f g))
+(assert (= g h))
+(assert (not (= f h)))
+(check-sat)
--- /dev/null
+(set-logic ALL_SUPPORTED)
+(set-info :status unsat)
+
+(define-funs-rec (
+(f () Int)
+(pred ((y Int)) Bool)) (
+0
+(ite (< y 0) false (ite (= y 0) true (pred (- y 2))))
+))
+
+(assert (pred 5))
+(check-sat)
projects / cvc5.git / commitdiff