diff options
46 files changed, 2127 insertions, 372 deletions
diff --git a/configure.ac b/configure.ac index e94733576..805a8daea 100644 --- a/configure.ac +++ b/configure.ac @@ -1035,6 +1035,10 @@ AC_CHECK_FUNC([ffs], [AC_DEFINE([HAVE_FFS], [1], AC_LIBOBJ([strtok_r ffs]) +# Check for sigaltstack (missing in emscripten and mingw) +AC_CHECK_FUNC([sigaltstack], [AC_DEFINE([HAVE_SIGALTSTACK], [1], + [Defined to 1 if sigaltstack() is supported by the platform.])]) + # Check for antlr C++ runtime (defined in config/antlr.m4) AC_LIB_ANTLR diff --git a/contrib/run-script-casc26-fnt b/contrib/run-script-casc26-fnt index bc37180a6..c3c12f937 100644 --- a/contrib/run-script-casc26-fnt +++ b/contrib/run-script-casc26-fnt @@ -7,7 +7,7 @@ bench="$1" file=${bench##*/} filename=${file%.*} -echo "------- cvc4-fnt casc j8 : $bench at $2..." +echo "------- cvc4-fnt casc 26 : $bench at $2..." # use: trywith [params..] # to attempt a run. If an SZS ontology result is printed, then diff --git a/contrib/run-script-casc26-fof b/contrib/run-script-casc26-fof index 77553a5ae..376d18b15 100644 --- a/contrib/run-script-casc26-fof +++ b/contrib/run-script-casc26-fof @@ -9,7 +9,7 @@ bench="$1" file=${bench##*/} filename=${file%.*} -echo "------- cvc4-fof casc j8 : $bench at $2..." +echo "------- cvc4-fof casc 26 : $bench at $2..." # use: trywith [params..] # to attempt a run. If an SZS ontology result is printed, then @@ -39,12 +39,11 @@ trywith 5 --multi-trigger-when-single --full-saturate-quant trywith 5 --trigger-sel=max --full-saturate-quant trywith 5 --multi-trigger-when-single --multi-trigger-priority --full-saturate-quant trywith 10 --multi-trigger-cache --full-saturate-quant -trywith 5 --no-multi-trigger-linear --full-saturate-quant -trywith 15 --finite-model-find --no-quant-cf --sort-inference --uf-ss-fair trywith 15 --prenex-quant=none --full-saturate-quant trywith 15 --fs-inst --decision=internal --full-saturate-quant trywith 15 --relevant-triggers --full-saturate-quant trywith 15 --finite-model-find --fmf-inst-engine --sort-inference --uf-ss-fair +trywith 30 --full-saturate-quant --macros-quant trywith 30 --fs-inst --full-saturate-quant trywith 30 --no-quant-cf --full-saturate-quant finishwith --qcf-vo-exp --full-saturate-quant diff --git a/contrib/run-script-casc26-tfa b/contrib/run-script-casc26-tfa index 9f6749ed6..aa65a938f 100644 --- a/contrib/run-script-casc26-tfa +++ b/contrib/run-script-casc26-tfa @@ -7,7 +7,7 @@ bench="$1" file=${bench##*/} filename=${file%.*} -echo "------- cvc4-tfa casc j8 : $bench at $2..." +echo "------- cvc4-tfa casc 26 : $bench at $2..." # use: trywith [params..] # to attempt a run. If an SZS ontology result is printed, then @@ -31,11 +31,9 @@ function finishwith { trywith 10 --decision=internal --full-saturate-quant trywith 10 --finite-model-find --decision=internal -trywith 10 --nl-ext --nl-ext-tplanes --decision=internal --full-saturate-quant -trywith 10 --purify-quant --full-saturate-quant +trywith 10 --nl-ext --nl-ext-tplanes --full-saturate-quant trywith 10 --partial-triggers --full-saturate-quant -trywith 10 --no-e-matching --full-saturate-quant -trywith 30 --cbqi-all --purify-triggers --full-saturate-quant -trywith 30 --nl-ext --fs-inst --full-saturate-quant -finishwith --nl-ext --nl-ext-tplanes --full-saturate-quant +trywith 15 --cbqi-all --purify-triggers --full-saturate-quant +trywith 15 --nl-ext --fs-inst --full-saturate-quant +finishwith --full-saturate-quant --macros-quant # echo "% SZS status" "GaveUp for $filename" diff --git a/contrib/run-script-smtcomp2017 b/contrib/run-script-smtcomp2017 index 9e351d58e..06cd6a6e4 100644 --- a/contrib/run-script-smtcomp2017 +++ b/contrib/run-script-smtcomp2017 @@ -11,7 +11,7 @@ logic=$(expr "$(grep -m1 '^[^;]*set-logic' "$bench")" : ' *(set-logic *\([A-Z_] # function returns normally. function trywith { limit=$1; shift; - result="$(ulimit -S -t "$limit";$cvc4 -L smt2 --no-incremental --no-checking --no-interactive "$@" $bench)" + result="$(ulimit -S -t "$limit";$cvc4 -L smt2.6 --no-incremental --no-checking --no-interactive "$@" $bench)" case "$result" in sat|unsat) echo "$result"; exit 0;; esac @@ -20,7 +20,7 @@ function trywith { # use: finishwith [params..] # to run cvc4 and let it output whatever it will to stdout. function finishwith { - $cvc4 -L smt2 --no-incremental --no-checking --no-interactive "$@" $bench + $cvc4 -L smt2.6 --no-incremental --no-checking --no-interactive "$@" $bench } case "$logic" in @@ -42,6 +42,7 @@ QF_NIA) finishwith --solve-int-as-bv=32 --bitblast=eager --bv-sat-solver=cryptominisat ;; QF_NRA) + trywith 300 --nl-ext --nl-ext-tplanes --decision=justification finishwith --nl-ext --nl-ext-tplanes ;; # all logics with UF + quantifiers should either fall under this or special cases below @@ -118,7 +119,7 @@ QF_UFBV) finishwith --bitblast=eager --bv-sat-solver=cryptominisat ;; QF_BV) - exec ./pcvc4 -L smt2 --no-incremental --no-checking --no-interactive --thread-stack=1024 \ + exec ./pcvc4 -L smt2.6 --no-incremental --no-checking --no-interactive --thread-stack=1024 \ --threads 2 \ --thread0 '--unconstrained-simp --bv-div-zero-const --bv-intro-pow2 --bitblast=eager --bv-sat-solver=cryptominisat --bitblast-aig --no-bv-abstraction' \ --thread1 '--unconstrained-simp --bv-div-zero-const --bv-intro-pow2 --bv-eq-slicer=auto --no-bv-abstraction' \ diff --git a/contrib/run-script-smtcomp2017-application b/contrib/run-script-smtcomp2017-application index 528a5deab..8a8ea7786 100644..100755 --- a/contrib/run-script-smtcomp2017-application +++ b/contrib/run-script-smtcomp2017-application @@ -2,13 +2,19 @@ cvc4=./cvc4-application -read line +line="" +while [[ -z "$line" ]]; do + read line +done if [ "$line" != '(set-option :print-success true)' ]; then echo 'ERROR: first line supposed to be set-option :print-success, but got: "'"$line"'"' >&2 exit 1 fi echo success -read line +line="" +while [[ -z "$line" ]]; do + read line +done logic=$(expr "$line" : ' *(set-logic *\([A-Z_]*\) *) *$') if [ -z "$logic" ]; then echo 'ERROR: second line supposed to be set-logic, but got: "'"$line"'"' >&2 @@ -20,7 +26,7 @@ function runcvc4 { # we run in this way for line-buffered input, otherwise memory's a # concern (plus it mimics what we'll end up getting from an # application-track trace runner?) - $cvc4 --force-logic="$logic" -L smt2 --print-success --no-checking --no-interactive "$@" <&0- + $cvc4 --force-logic="$logic" -L smt2.6 --print-success --no-checking --no-interactive "$@" <&0- } case "$logic" in diff --git a/contrib/run-script-smtcomp2017-unsat-cores b/contrib/run-script-smtcomp2017-unsat-cores new file mode 100644 index 000000000..116a9b3a7 --- /dev/null +++ b/contrib/run-script-smtcomp2017-unsat-cores @@ -0,0 +1,148 @@ +#!/bin/bash + +cvc4=./cvc4 +bench="$1" + +logic=$(expr "$(grep -m1 '^[^;]*set-logic' "$bench")" : ' *(set-logic *\([A-Z_]*\) *) *$') + +# use: trywith [params..] +# to attempt a run. Only thing printed on stdout is "sat" or "unsat", in +# which case this run script terminates immediately. Otherwise, this +# function returns normally. +function trywith { + limit=$1; shift; + result="$(ulimit -S -t "$limit";$cvc4 -L smt2.6 --no-incremental --no-checking --no-interactive "$@" $bench)" + case "$result" in + sat|unsat) echo "$result"; exit 0;; + esac +} + +# use: finishwith [params..] +# to run cvc4 and let it output whatever it will to stdout. +function finishwith { + $cvc4 -L smt2.6 --no-incremental --no-checking --no-interactive "$@" $bench +} + +case "$logic" in + +QF_LRA) + trywith 200 --enable-miplib-trick --miplib-trick-subs=4 --use-approx --lemmas-on-replay-failure --replay-early-close-depth=4 --replay-lemma-reject-cut=128 --replay-reject-cut=512 --unconstrained-simp --use-soi + finishwith --no-restrict-pivots --use-soi --new-prop --unconstrained-simp + ;; +QF_LIA) + # same as QF_LRA but add --pb-rewrites + finishwith --enable-miplib-trick --miplib-trick-subs=4 --use-approx --lemmas-on-replay-failure --replay-early-close-depth=4 --replay-lemma-reject-cut=128 --replay-reject-cut=512 --unconstrained-simp --use-soi --pb-rewrites + ;; +QF_NIA) + trywith 300 --nl-ext --nl-ext-tplanes --decision=internal + trywith 1800 --solve-int-as-bv=2 --bitblast=eager --bv-sat-solver=cryptominisat + trywith 1800 --solve-int-as-bv=4 --bitblast=eager --bv-sat-solver=cryptominisat + trywith 1800 --solve-int-as-bv=8 --bitblast=eager --bv-sat-solver=cryptominisat + trywith 1800 --solve-int-as-bv=16 --bitblast=eager --bv-sat-solver=cryptominisat + finishwith --solve-int-as-bv=32 --bitblast=eager --bv-sat-solver=cryptominisat + ;; +QF_NRA) + trywith 300 --nl-ext --nl-ext-tplanes --decision=justification + finishwith --nl-ext --nl-ext-tplanes + ;; +# all logics with UF + quantifiers should either fall under this or special cases below +ALIA|AUFLIA|AUFLIRA|AUFNIRA|UF|UFIDL|UFLIA|UFLRA|UFNIA|UFDT|UFDTLIA|AUFDTLIA|AUFBVDTLIA) + # the following is designed for a run time of 2400s (40 min). + # initial runs 1min + trywith 20 --simplification=none --full-saturate-quant + trywith 20 --no-e-matching --full-saturate-quant + trywith 20 --fs-inst --decision=internal --full-saturate-quant + # trigger selections 3min + trywith 30 --relevant-triggers --full-saturate-quant + trywith 30 --trigger-sel=max --full-saturate-quant + trywith 30 --multi-trigger-when-single --full-saturate-quant + trywith 30 --multi-trigger-when-single --multi-trigger-priority --full-saturate-quant + trywith 30 --multi-trigger-cache --full-saturate-quant + trywith 30 --no-multi-trigger-linear --full-saturate-quant + # other 3min + trywith 30 --pre-skolem-quant --full-saturate-quant + trywith 30 --inst-when=full --full-saturate-quant + trywith 30 --no-e-matching --no-quant-cf --full-saturate-quant + trywith 30 --nl-ext --full-saturate-quant + trywith 30 --full-saturate-quant --quant-ind + trywith 60 --decision=internal --simplification=none --no-inst-no-entail --no-quant-cf --full-saturate-quant + # finite model find 2min + trywith 20 --finite-model-find --mbqi=none + trywith 20 --finite-model-find + trywith 20 --finite-model-find --uf-ss=no-minimal + trywith 60 --finite-model-find --fmf-inst-engine + # long runs 20min + trywith 200 --decision=internal --full-saturate-quant + trywith 200 --term-db-mode=relevant --full-saturate-quant + trywith 200 --fs-inst --full-saturate-quant + trywith 600 --finite-model-find --decision=internal + # finite model find 1min + trywith 30 --finite-model-find --fmf-bound-int + trywith 30 --finite-model-find --sort-inference + # finish 10min + finishwith --full-saturate-quant + ;; +UFBV) + # most problems in UFBV are essentially BV + trywith 300 --full-saturate-quant + trywith 300 --full-saturate-quant --no-cbqi + trywith 300 --full-saturate-quant --cbqi --decision=internal + finishwith --finite-model-find + ;; +BV) + trywith 300 --full-saturate-quant + trywith 300 --full-saturate-quant --no-cbqi + finishwith --full-saturate-quant --cbqi --decision=internal + ;; +LIA|LRA) + trywith 30 --full-saturate-quant + trywith 300 --full-saturate-quant --cbqi-midpoint + trywith 300 --full-saturate-quant --cbqi-nested-qe + finishwith --full-saturate-quant --cbqi --cbqi-nested-qe --decision=internal + ;; +NIA|NRA) + trywith 30 --full-saturate-quant + trywith 300 --full-saturate-quant --nl-ext + trywith 300 --full-saturate-quant --cbqi-nested-qe + finishwith --full-saturate-quant --cbqi --cbqi-nested-qe --decision=internal + ;; +QF_AUFBV) + trywith 600 + finishwith --decision=justification-stoponly + ;; +QF_ABV) + trywith 50 --ite-simp --simp-with-care --repeat-simp --arrays-weak-equiv + trywith 500 --arrays-weak-equiv + finishwith --ite-simp --simp-with-care --repeat-simp --arrays-weak-equiv + ;; +QF_UFBV) + finishwith --bitblast=eager --bv-sat-solver=cryptominisat + ;; +QF_BV) + trywith 300 --unconstrained-simp --bv-div-zero-const --bv-intro-pow2 --bitblast=eager --bv-sat-solver=cryptominisat --bitblast-aig --no-bv-abstraction + finishwith --unconstrained-simp --bv-div-zero-const --bv-intro-pow2 --bv-eq-slicer=auto --no-bv-abstraction + #trywith 10 --bv-eq-slicer=auto --decision=justification + #trywith 60 --decision=justification + #trywith 600 --decision=internal --bitblast-eager + #finishwith --decision=justification --decision-use-weight --decision-weight-internal=usr1 + ;; +QF_AUFLIA) + finishwith --no-arrays-eager-index --arrays-eager-lemmas --decision=justification + ;; +QF_AX) + finishwith --no-arrays-eager-index --arrays-eager-lemmas --decision=internal + ;; +QF_AUFNIA) + finishwith --decision=justification --no-arrays-eager-index --arrays-eager-lemmas + ;; +QF_ALIA) + trywith 70 --decision=justification --arrays-weak-equiv + finishwith --decision=justification-stoponly --no-arrays-eager-index --arrays-eager-lemmas + ;; +*) + # just run the default + finishwith + ;; + +esac + diff --git a/contrib/run-script-sygusComp2017-INV b/contrib/run-script-sygusComp2017-INV index a25a5f5c8..a21792fb9 100755 --- a/contrib/run-script-sygusComp2017-INV +++ b/contrib/run-script-sygusComp2017-INV @@ -3,14 +3,31 @@ cvc4=./cvc4 bench="$1" +function runl { + limit=$1; shift; + ulimit -S -t "$limit";$cvc4 --lang=sygus --no-checking --no-interactive --dump-synth --default-dag-thresh=0 "$@" $bench +} + function trywith { - ($cvc4 --lang=sygus --no-checking --no-interactive --dump-synth --default-dag-thresh=0 "$@" $bench) 2>/dev/null | + sol=$(runl $@) + status=$? + if [ $status -ne 134 ]; then + echo $sol | + (read result w1; + case "$result" in + unsat) echo "$w1";cat;exit 0;; + esac; exit 1) + if [ ${PIPESTATUS[1]} -eq 0 ]; then exit 0; fi + fi +} + +function finishwith { + $cvc4 --lang=sygus --no-checking --no-interactive --dump-synth --default-dag-thresh=0 "$@" $bench 2>/dev/null | (read result w1; case "$result" in unsat) echo "$w1";cat;exit 0;; - esac; exit 1) - if [ ${PIPESTATUS[1]} -eq 0 ]; then exit 0; fi + esac) } -trywith --sygus-inv-templ=post - +trywith 60 --sygus-inv-templ=pre +finishwith --sygus-inv-templ=post diff --git a/contrib/run-script-sygusComp2017-PBE_Strings b/contrib/run-script-sygusComp2017-PBE_Strings index 0a845bd78..849835b28 100755 --- a/contrib/run-script-sygusComp2017-PBE_Strings +++ b/contrib/run-script-sygusComp2017-PBE_Strings @@ -12,5 +12,5 @@ function trywith { if [ ${PIPESTATUS[1]} -eq 0 ]; then exit 0; fi } -trywith --cegqi-si=none --strings-exp +trywith --cegqi-si=none --sygus-fair=direct diff --git a/src/main/util.cpp b/src/main/util.cpp index 72f431b0d..2fd796d92 100644 --- a/src/main/util.cpp +++ b/src/main/util.cpp @@ -66,8 +66,10 @@ void print_statistics() { #ifndef __WIN32__ +#ifdef HAVE_SIGALTSTACK size_t cvc4StackSize; void* cvc4StackBase; +#endif /* HAVE_SIGALTSTACK */ /** Handler for SIGXCPU, i.e., timeout. */ void timeout_handler(int sig, siginfo_t* info, void*) { @@ -83,6 +85,7 @@ void sigint_handler(int sig, siginfo_t* info, void*) { abort(); } +#ifdef HAVE_SIGALTSTACK /** Handler for SIGSEGV (segfault). */ void segv_handler(int sig, siginfo_t* info, void* c) { uintptr_t extent = reinterpret_cast<uintptr_t>(cvc4StackBase) - cvc4StackSize; @@ -143,6 +146,7 @@ void segv_handler(int sig, siginfo_t* info, void* c) { abort(); #endif /* CVC4_DEBUG */ } +#endif /* HAVE_SIGALTSTACK */ /** Handler for SIGILL (illegal instruction). */ void ill_handler(int sig, siginfo_t* info, void*) { @@ -256,16 +260,6 @@ void cvc4_init() throw(Exception) { #endif #ifndef __WIN32__ - stack_t ss; - ss.ss_sp = (char*) malloc(SIGSTKSZ); - if(ss.ss_sp == NULL) { - throw Exception("Can't malloc() space for a signal stack"); - } - ss.ss_size = SIGSTKSZ; - ss.ss_flags = 0; - if(sigaltstack(&ss, NULL) == -1) { - throw Exception(string("sigaltstack() failure: ") + strerror(errno)); - } struct rlimit limit; if(getrlimit(RLIMIT_STACK, &limit)) { throw Exception(string("getrlimit() failure: ") + strerror(errno)); @@ -279,8 +273,6 @@ void cvc4_init() throw(Exception) { throw Exception(string("getrlimit() failure: ") + strerror(errno)); } } - cvc4StackSize = limit.rlim_cur; - cvc4StackBase = ss.ss_sp; struct sigaction act1; act1.sa_sigaction = sigint_handler; @@ -299,20 +291,36 @@ void cvc4_init() throw(Exception) { } struct sigaction act3; - act3.sa_sigaction = segv_handler; - act3.sa_flags = SA_SIGINFO | SA_ONSTACK; + act3.sa_sigaction = ill_handler; + act3.sa_flags = SA_SIGINFO; sigemptyset(&act3.sa_mask); - if(sigaction(SIGSEGV, &act3, NULL)) { - throw Exception(string("sigaction(SIGSEGV) failure: ") + strerror(errno)); + if(sigaction(SIGILL, &act3, NULL)) { + throw Exception(string("sigaction(SIGILL) failure: ") + strerror(errno)); + } + +#ifdef HAVE_SIGALTSTACK + stack_t ss; + ss.ss_sp = (char*) malloc(SIGSTKSZ); + if(ss.ss_sp == NULL) { + throw Exception("Can't malloc() space for a signal stack"); + } + ss.ss_size = SIGSTKSZ; + ss.ss_flags = 0; + if(sigaltstack(&ss, NULL) == -1) { + throw Exception(string("sigaltstack() failure: ") + strerror(errno)); } + cvc4StackSize = limit.rlim_cur; + cvc4StackBase = ss.ss_sp; + struct sigaction act4; act4.sa_sigaction = segv_handler; - act4.sa_flags = SA_SIGINFO; + act4.sa_flags = SA_SIGINFO | SA_ONSTACK; sigemptyset(&act4.sa_mask); - if(sigaction(SIGILL, &act4, NULL)) { - throw Exception(string("sigaction(SIGILL) failure: ") + strerror(errno)); + if(sigaction(SIGSEGV, &act4, NULL)) { + throw Exception(string("sigaction(SIGSEGV) failure: ") + strerror(errno)); } +#endif /* HAVE_SIGALTSTACK */ #endif /* __WIN32__ */ @@ -322,9 +330,11 @@ void cvc4_init() throw(Exception) { void cvc4_shutdown() throw () { #ifndef __WIN32__ +#ifdef HAVE_SIGALTSTACK free(cvc4StackBase); cvc4StackBase = NULL; cvc4StackSize = 0; +#endif /* HAVE_SIGALTSTACK */ #endif /* __WIN32__ */ } diff --git a/src/parser/Makefile.am b/src/parser/Makefile.am index ca10de684..a316019fd 100644 --- a/src/parser/Makefile.am +++ b/src/parser/Makefile.am @@ -46,6 +46,8 @@ libcvc4parser_la_SOURCES = \ bounded_token_factory.h \ input.cpp \ input.h \ + line_buffer.cpp \ + line_buffer.h \ memory_mapped_input_buffer.cpp \ memory_mapped_input_buffer.h \ parser.cpp \ diff --git a/src/parser/antlr_input.cpp b/src/parser/antlr_input.cpp index b2f2cdd53..cbdaaa2bf 100644 --- a/src/parser/antlr_input.cpp +++ b/src/parser/antlr_input.cpp @@ -50,23 +50,26 @@ namespace parser { // These functions exactly wrap the antlr3 source inconsistencies. // These are the only location CVC4_ANTLR3_OLD_INPUT_STREAM ifdefs appear. // No other sanity checking happens; -pANTLR3_INPUT_STREAM newAntlr3BufferedStream(std::istream& input, const std::string& name); +pANTLR3_INPUT_STREAM newAntlr3BufferedStream(std::istream& input, + const std::string& name, + LineBuffer* line_buffer); pANTLR3_INPUT_STREAM newAntlr3FileStream(const std::string& name); pANTLR3_INPUT_STREAM newAntrl3InPlaceStream(pANTLR3_UINT8 basep, uint32_t size, const std::string& name); -pANTLR3_INPUT_STREAM -newAntlr3BufferedStream(std::istream& input, const std::string& name){ +pANTLR3_INPUT_STREAM newAntlr3BufferedStream(std::istream& input, + const std::string& name, + LineBuffer* line_buffer) { pANTLR3_INPUT_STREAM inputStream = NULL; pANTLR3_UINT8 name_duplicate = (pANTLR3_UINT8) strdup(name.c_str()); #ifdef CVC4_ANTLR3_OLD_INPUT_STREAM inputStream = - antlr3LineBufferedStreamNew(input, 0, name_duplicate); + antlr3LineBufferedStreamNew(input, 0, name_duplicate, line_buffer); #else /* CVC4_ANTLR3_OLD_INPUT_STREAM */ - inputStream = - antlr3LineBufferedStreamNew(input, ANTLR3_ENC_8BIT, name_duplicate); + inputStream = antlr3LineBufferedStreamNew(input, ANTLR3_ENC_8BIT, + name_duplicate, line_buffer); #endif /* CVC4_ANTLR3_OLD_INPUT_STREAM */ free(name_duplicate); @@ -107,14 +110,14 @@ pANTLR3_INPUT_STREAM newAntrl3InPlaceStream(pANTLR3_UINT8 basep, return inputStream; } -AntlrInputStream::AntlrInputStream(std::string name, - pANTLR3_INPUT_STREAM input, +AntlrInputStream::AntlrInputStream(std::string name, pANTLR3_INPUT_STREAM input, bool fileIsTemporary, - pANTLR3_UINT8 inputString) : - InputStream(name, fileIsTemporary), - d_input(input), - d_inputString(inputString) -{ + pANTLR3_UINT8 inputString, + LineBuffer* line_buffer) + : InputStream(name, fileIsTemporary), + d_input(input), + d_inputString(inputString), + d_line_buffer(line_buffer) { assert( input != NULL ); input->fileName = input->strFactory->newStr8(input->strFactory, (pANTLR3_UINT8)name.c_str()); } @@ -124,6 +127,9 @@ AntlrInputStream::~AntlrInputStream() { if(d_inputString != NULL){ free(d_inputString); } + if (d_line_buffer != NULL) { + delete d_line_buffer; + } } pANTLR3_INPUT_STREAM AntlrInputStream::getAntlr3InputStream() const { @@ -150,7 +156,7 @@ AntlrInputStream::newFileInputStream(const std::string& name, if(input == NULL) { throw InputStreamException("Couldn't open file: " + name); } - return new AntlrInputStream( name, input, false, NULL ); + return new AntlrInputStream(name, input, false, NULL, NULL); } @@ -162,9 +168,11 @@ AntlrInputStream::newStreamInputStream(std::istream& input, pANTLR3_INPUT_STREAM inputStream = NULL; pANTLR3_UINT8 inputStringCopy = NULL; + LineBuffer* line_buffer = NULL; if(lineBuffered) { - inputStream = newAntlr3BufferedStream(input, name); + line_buffer = new LineBuffer(&input); + inputStream = newAntlr3BufferedStream(input, name, line_buffer); } else { // Since these are all NULL on entry, realloc will be called @@ -207,7 +215,8 @@ AntlrInputStream::newStreamInputStream(std::istream& input, throw InputStreamException("Couldn't initialize input: " + name); } - return new AntlrInputStream( name, inputStream, false, inputStringCopy ); + return new AntlrInputStream(name, inputStream, false, inputStringCopy, + line_buffer); } @@ -230,7 +239,7 @@ AntlrInputStream::newStringInputStream(const std::string& input, if( inputStream==NULL ) { throw InputStreamException("Couldn't initialize string input: '" + input + "'"); } - return new AntlrInputStream( name, inputStream, false, input_duplicate ); + return new AntlrInputStream(name, inputStream, false, input_duplicate, NULL); } AntlrInput* AntlrInput::newInput(InputLanguage lang, AntlrInputStream& inputStream) { diff --git a/src/parser/antlr_input.h b/src/parser/antlr_input.h index 8e5e82811..293be0087 100644 --- a/src/parser/antlr_input.h +++ b/src/parser/antlr_input.h @@ -35,12 +35,12 @@ #include "base/output.h" #include "parser/bounded_token_buffer.h" #include "parser/input.h" +#include "parser/line_buffer.h" #include "parser/parser_exception.h" #include "util/bitvector.h" #include "util/integer.h" #include "util/rational.h" - namespace CVC4 { class Command; @@ -62,10 +62,11 @@ private: */ pANTLR3_UINT8 d_inputString; - AntlrInputStream(std::string name, - pANTLR3_INPUT_STREAM input, - bool fileIsTemporary, - pANTLR3_UINT8 inputString); + LineBuffer* d_line_buffer; + + AntlrInputStream(std::string name, pANTLR3_INPUT_STREAM input, + bool fileIsTemporary, pANTLR3_UINT8 inputString, + LineBuffer* line_buffer); /* This is private and unimplemented, because you should never use it. */ AntlrInputStream(const AntlrInputStream& inputStream) CVC4_UNDEFINED; @@ -201,9 +202,6 @@ public: /** Get a bitvector constant from the text of the number and the size token */ static BitVector tokenToBitvector(pANTLR3_COMMON_TOKEN number, pANTLR3_COMMON_TOKEN size); - /** Retrieve the remaining text in this input. */ - std::string getUnparsedText(); - /** Get the ANTLR3 lexer for this input. */ pANTLR3_LEXER getAntlr3Lexer() { return d_lexer; } @@ -243,14 +241,6 @@ protected: virtual void setParser(Parser& parser); };/* class AntlrInput */ -inline std::string AntlrInput::getUnparsedText() { - const char *base = (const char *)d_antlr3InputStream->data; - const char *cur = (const char *)d_antlr3InputStream->nextChar; - - return std::string(cur, d_antlr3InputStream->sizeBuf - (cur - base)); -} - - inline std::string AntlrInput::tokenText(pANTLR3_COMMON_TOKEN token) { if( token->type == ANTLR3_TOKEN_EOF ) { return "<<EOF>>"; diff --git a/src/parser/antlr_line_buffered_input.cpp b/src/parser/antlr_line_buffered_input.cpp index 22bbaf1db..e65125ad9 100644 --- a/src/parser/antlr_line_buffered_input.cpp +++ b/src/parser/antlr_line_buffered_input.cpp @@ -2,17 +2,30 @@ /*! \file antlr_line_buffered_input.cpp ** \verbatim ** Top contributors (to current version): - ** Morgan Deters, Tim King + ** Morgan Deters, Tim King, Andres Noetzli ** This file is part of the CVC4 project. ** Copyright (c) 2009-2016 by the authors listed in the file AUTHORS ** in the top-level source directory) and their institutional affiliations. ** All rights reserved. See the file COPYING in the top-level source ** directory for licensing information.\endverbatim ** - ** \brief [[ Add one-line brief description here ]] + ** \brief A custom ANTLR input stream that reads from the input stream lazily ** - ** [[ Add lengthier description here ]] - ** \todo document this file + ** WARNING: edits to this and related files should be done carefully due to the + *interaction with ANTLR internals. + ** + ** This overwrites the _LA and the consume functions of the ANTLR input stream + ** to use a LineBuffer instead of accessing a buffer. The lines are kept in + ** memory to make sure that existing tokens remain valid (tokens store pointers + ** to the corresponding input). We do not overwrite mark(), etc. + *because + ** we can use the line number and the position within that line to index into + *the + ** line buffer and the default markers already store and restore that + ** information. The line buffer guarantees that lines are consecutive in + ** memory, so ANTLR3_INPUT_STREAM::getLineBuf() should work as intended and + ** tokens themselves are consecutive in memory (we are assuming that tokens + ** are not split across multiple lines). **/ // We rely on the inclusion of #include <antlr3.h> in @@ -32,7 +45,8 @@ namespace CVC4 { namespace parser { -static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream(std::istream& in); +static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream( + std::istream& in, LineBuffer* line_buffer); static void setupInputStream(pANTLR3_INPUT_STREAM input) @@ -206,111 +220,133 @@ setupInputStream(pANTLR3_INPUT_STREAM input) #endif /* 0 */ } -static ANTLR3_UCHAR -myLA(pANTLR3_INT_STREAM is, ANTLR3_INT32 la) { - pANTLR3_INPUT_STREAM input; +static ANTLR3_UCHAR bufferedInputLA(pANTLR3_INT_STREAM is, ANTLR3_INT32 la) { + pANTLR3_INPUT_STREAM input = ((pANTLR3_INPUT_STREAM)(is->super)); + CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input = + (CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input; + uint8_t* result = line_buffered_input->line_buffer->getPtrWithOffset( + input->line, input->charPositionInLine, la - 1); + return (result != NULL) ? *result : ANTLR3_CHARSTREAM_EOF; +} - input = ((pANTLR3_INPUT_STREAM) (is->super)); +static void bufferedInputRewind(pANTLR3_INT_STREAM is, ANTLR3_MARKER mark) { + // This function is essentially the same as the original + // antlr38BitRewind() but does not do any seek. The seek in the + // original function does not do anything and also calls + // antlr38BitSeek() instead of the overloaded seek() function, which + // leads to subtle bugs. + pANTLR3_LEX_STATE state; + pANTLR3_INPUT_STREAM input; + + input = ((pANTLR3_INPUT_STREAM)is->super); + + // Perform any clean up of the marks + input->istream->release(input->istream, mark); + + // Find the supplied mark state + state = (pANTLR3_LEX_STATE)input->markers->get(input->markers, + (ANTLR3_UINT32)(mark - 1)); + if (state == NULL) { + return; + } + + // Reset the information in the mark + input->charPositionInLine = state->charPositionInLine; + input->currentLine = state->currentLine; + input->line = state->line; + input->nextChar = state->nextChar; +} - Debug("pipe") << "LA" << std::endl; - if (( ((pANTLR3_UINT8)input->nextChar) + la - 1) >= (((pANTLR3_UINT8)input->data) + input->sizeBuf)) - { - std::istream& in = *((CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input)->in; - //MGD - // in.clear(); - if(!in) { - Debug("pipe") << "EOF" << std::endl; - return ANTLR3_CHARSTREAM_EOF; - } - Debug("pipe") << "READ" << std::endl; - if(input->data == NULL) { - Debug("pipe") << "ALLOC" << std::endl; - input->data = malloc(1024); - input->nextChar = input->data; - } else { - Debug("pipe") << "REALLOC" << std::endl; - size_t pos = (char*)input->nextChar - (char*)input->data; - input->data = realloc(input->data, input->sizeBuf + 1024); - input->nextChar = (char*)input->data + pos; - } - in.getline((((char*)input->data) + input->sizeBuf), 1024); - while(in.fail() && !in.eof()) { - Debug("pipe") << "input string too long, reallocating" << std::endl; - input->sizeBuf += strlen(((char*)input->data) + input->sizeBuf); - size_t pos = (char*)input->nextChar - (char*)input->data; - input->data = realloc(input->data, input->sizeBuf + 1024); - input->nextChar = (char*)input->data + pos; - in.clear(); - in.getline((((char*)input->data) + input->sizeBuf), 1024); - } - input->sizeBuf += strlen(((char*)input->data) + input->sizeBuf); - assert(*(((char*)input->data) + input->sizeBuf) == '\0'); - Debug("pipe") << "SIZEBUF now " << input->sizeBuf << std::endl; - *(((char*)input->data) + input->sizeBuf) = '\n'; - ++input->sizeBuf; +static void bufferedInputConsume(pANTLR3_INT_STREAM is) { + pANTLR3_INPUT_STREAM input = ((pANTLR3_INPUT_STREAM)(is->super)); + CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input = + (CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input; + + uint8_t* current = line_buffered_input->line_buffer->getPtr( + input->line, input->charPositionInLine); + if (current != NULL) { + input->charPositionInLine++; + + if (*current == LineBuffer::NewLineChar) { + // Reset for start of a new line of input + input->line++; + input->charPositionInLine = 0; + input->currentLine = line_buffered_input->line_buffer->getPtr( + input->line, input->charPositionInLine); + Debug("pipe") << "-- newline!" << std::endl; } - Debug("pipe") << "READ POINTER[" << la << "] AT: >>" << std::string(((char*)input->nextChar), input->sizeBuf - (((char*)input->nextChar) - (char*)input->data)) << "<< returning '" << (char)(*((pANTLR3_UINT8)input->nextChar + la - 1)) << "' (" << (unsigned)(*((pANTLR3_UINT8)input->nextChar + la - 1)) << ")" << std::endl; - return (ANTLR3_UCHAR)(*((pANTLR3_UINT8)input->nextChar + la - 1)); + input->nextChar = line_buffered_input->line_buffer->getPtr( + input->line, input->charPositionInLine); + } } - -static void -myConsume(pANTLR3_INT_STREAM is) -{ - pANTLR3_INPUT_STREAM input; - - input = ((pANTLR3_INPUT_STREAM) (is->super)); - - Debug("pipe") << "consume! '" << *(char*)input->nextChar << "' (" << (unsigned)*(char*)input->nextChar << ")" << std::endl; - if ((pANTLR3_UINT8)(input->nextChar) < (((pANTLR3_UINT8)input->data) + input->sizeBuf)) - { - /* Indicate one more character in this line - */ - input->charPositionInLine++; - - if ((ANTLR3_UCHAR)(*((pANTLR3_UINT8)input->nextChar)) == input->newlineChar) - { - /* Reset for start of a new line of input - */ - input->line++; - input->charPositionInLine = 0; - input->currentLine = (void *)(((pANTLR3_UINT8)input->nextChar) + 1); - Debug("pipe") << "-- newline!" << std::endl; - } - - /* Increment to next character position - */ - input->nextChar = (void *)(((pANTLR3_UINT8)input->nextChar) + 1); - Debug("pipe") << "-- advance nextChar! looking at '" << *(char*)input->nextChar << "' (" << (unsigned)*(char*)input->nextChar << ")" << std::endl; - } else Debug("pipe") << "-- nothing!" << std::endl; +static void bufferedInputSeek(pANTLR3_INT_STREAM is, ANTLR3_MARKER seekPoint) { + // In contrast to the original antlr38BitSeek() function, we only + // support seeking forward (seeking backwards is only supported for + // rewinding in the original code, which we do not do when rewinding, + // so this should be fine). + pANTLR3_INPUT_STREAM input = ((pANTLR3_INPUT_STREAM)(is->super)); + pANTLR3_LINE_BUFFERED_INPUT_STREAM line_buffered_input = + (CVC4::parser::pANTLR3_LINE_BUFFERED_INPUT_STREAM)input; + + // Check that we are not seeking backwards. + assert(!line_buffered_input->line_buffer->isPtrBefore( + (uint8_t*)seekPoint, input->line, input->charPositionInLine)); + + ssize_t count = (ssize_t)(seekPoint - (ANTLR3_MARKER)(input->nextChar)); + while (count > 0) { + is->consume(is); + count--; + } } -pANTLR3_INPUT_STREAM -antlr3LineBufferedStreamNew(std::istream& in, ANTLR3_UINT32 encoding, pANTLR3_UINT8 name) -{ - pANTLR3_INPUT_STREAM input; - - if(!in) { - return NULL; - } +static ANTLR3_UINT32 bufferedInputSize(pANTLR3_INPUT_STREAM input) { + // Not supported for this type of stream + assert(false); + return 0; +} - // First order of business is to set up the stream and install the data pointer. - // Then we will work out the encoding and byte order and adjust the API functions that are installed for the - // default 8Bit stream accordingly. - // - input = antlr3CreateLineBufferedStream(in); - if (input == NULL) - { - return NULL; - } +static void bufferedInputSetNewLineChar(pANTLR3_INPUT_STREAM input, + ANTLR3_UINT32 newlineChar) { + // Not supported for this type of stream + assert(false); +} - // Size (in bytes) of the given 'string' - // - input->sizeBuf = 0; +static void bufferedInputSetUcaseLA(pANTLR3_INPUT_STREAM input, + ANTLR3_BOOLEAN flag) { + // Not supported for this type of stream + assert(false); +} - input->istream->_LA = myLA; - input->istream->consume = myConsume; +pANTLR3_INPUT_STREAM antlr3LineBufferedStreamNew(std::istream& in, + ANTLR3_UINT32 encoding, + pANTLR3_UINT8 name, + LineBuffer* line_buffer) { + pANTLR3_INPUT_STREAM input; + + if (!in) { + return NULL; + } + + // First order of business is to set up the stream and install the data + // pointer. + // Then we will work out the encoding and byte order and adjust the API + // functions that are installed for the + // default 8Bit stream accordingly. + // + input = antlr3CreateLineBufferedStream(in, line_buffer); + if (input == NULL) { + return NULL; + } + + input->istream->_LA = bufferedInputLA; + input->istream->consume = bufferedInputConsume; + input->istream->seek = bufferedInputSeek; + input->istream->rewind = bufferedInputRewind; + input->size = bufferedInputSize; + input->SetNewLineChar = bufferedInputSetNewLineChar; + input->setUcaseLA = bufferedInputSetUcaseLA; #ifndef CVC4_ANTLR3_OLD_INPUT_STREAM // We have the data in memory now so we can deal with it according to @@ -326,53 +362,60 @@ antlr3LineBufferedStreamNew(std::istream& in, ANTLR3_UINT32 encoding, pANTLR3_UI // Now we can set up the file name // - input->istream->streamName = input->strFactory->newStr8(input->strFactory, name); - input->fileName = input->istream->streamName; + input->istream->streamName = + input->strFactory->newStr8(input->strFactory, name); + input->fileName = input->istream->streamName; return input; } -static pANTLR3_INPUT_STREAM -antlr3CreateLineBufferedStream(std::istream& in) -{ - // Pointer to the input stream we are going to create - // - pANTLR3_INPUT_STREAM input; - - if (!in) - { - return NULL; - } - - // Allocate memory for the input stream structure - // - input = (pANTLR3_INPUT_STREAM) - ANTLR3_CALLOC(1, sizeof(ANTLR3_LINE_BUFFERED_INPUT_STREAM)); - - if (input == NULL) - { - return NULL; - } - - // Structure was allocated correctly, now we can install the pointer - // - input->data = malloc(1024); - input->isAllocated = ANTLR3_FALSE; - - ((pANTLR3_LINE_BUFFERED_INPUT_STREAM)input)->in = ∈ - // Call the common 8 bit input stream handler - // initialization. - // +static pANTLR3_INPUT_STREAM antlr3CreateLineBufferedStream( + std::istream& in, LineBuffer* line_buffer) { + // Pointer to the input stream we are going to create + // + pANTLR3_INPUT_STREAM input; + + if (!in) { + return NULL; + } + + // Allocate memory for the input stream structure + // + input = (pANTLR3_INPUT_STREAM)ANTLR3_CALLOC( + 1, sizeof(ANTLR3_LINE_BUFFERED_INPUT_STREAM)); + + if (input == NULL) { + return NULL; + } + + // Structure was allocated correctly, now we can install the pointer + // + input->data = NULL; + input->isAllocated = ANTLR3_FALSE; + + ((pANTLR3_LINE_BUFFERED_INPUT_STREAM)input)->in = ∈ + ((pANTLR3_LINE_BUFFERED_INPUT_STREAM)input)->line_buffer = line_buffer; +// Call the common 8 bit input stream handler +// initialization. +// #ifdef CVC4_ANTLR3_OLD_INPUT_STREAM - antlr3AsciiSetupStream(input, ANTLR3_CHARSTREAM); + antlr3AsciiSetupStream(input, ANTLR3_CHARSTREAM); #else /* CVC4_ANTLR3_OLD_INPUT_STREAM */ - antlr38BitSetupStream(input); - // In some libantlr3c 3.4-beta versions, this call is not included in the above. - // This is probably an erroneously-deleted line in the libantlr3c source since 3.2. - antlr3GenericSetupStream(input); + antlr38BitSetupStream(input); + // In some libantlr3c 3.4-beta versions, this call is not included in the + // above. + // This is probably an erroneously-deleted line in the libantlr3c source since + // 3.2. + antlr3GenericSetupStream(input); #endif /* CVC4_ANTLR3_OLD_INPUT_STREAM */ - return input; + input->sizeBuf = 0; + input->newlineChar = LineBuffer::NewLineChar; + input->charPositionInLine = 0; + input->line = 0; + input->nextChar = line_buffer->getPtr(0, 0); + input->currentLine = line_buffer->getPtr(0, 0); + return input; } }/* CVC4::parser namespace */ diff --git a/src/parser/antlr_line_buffered_input.h b/src/parser/antlr_line_buffered_input.h index 2c01a9bde..4535ffe6b 100644 --- a/src/parser/antlr_line_buffered_input.h +++ b/src/parser/antlr_line_buffered_input.h @@ -2,17 +2,22 @@ /*! \file antlr_line_buffered_input.h ** \verbatim ** Top contributors (to current version): - ** Morgan Deters, Tim King + ** Morgan Deters, Tim King, Andres Noetzli ** This file is part of the CVC4 project. ** Copyright (c) 2009-2016 by the authors listed in the file AUTHORS ** in the top-level source directory) and their institutional affiliations. ** All rights reserved. See the file COPYING in the top-level source ** directory for licensing information.\endverbatim ** - ** \brief [[ Add one-line brief description here ]] + ** \brief A custom ANTLR input stream that reads from the input stream lazily ** - ** [[ Add lengthier description here ]] - ** \todo document this file + ** By default, ANTLR expects the whole input to be in a single, consecutive + ** buffer. When doing incremental solving and the input is coming from the + ** standard input, this is problematic because CVC4 might receive new input + ** based on the result of solving the existing input. + ** + ** This file overwrites the _LA and the consume functions of the input streamto + ** achieve that and stores the lines received so far in a LineBuffer. **/ // These headers should be the first two included. @@ -27,16 +32,21 @@ #include <istream> +#include "parser/line_buffer.h" + namespace CVC4 { namespace parser { typedef struct ANTLR3_LINE_BUFFERED_INPUT_STREAM { ANTLR3_INPUT_STREAM antlr; std::istream* in; + LineBuffer* line_buffer; } *pANTLR3_LINE_BUFFERED_INPUT_STREAM; -pANTLR3_INPUT_STREAM -antlr3LineBufferedStreamNew(std::istream& in, ANTLR3_UINT32 encoding, pANTLR3_UINT8 name); +pANTLR3_INPUT_STREAM antlr3LineBufferedStreamNew(std::istream& in, + ANTLR3_UINT32 encoding, + pANTLR3_UINT8 name, + LineBuffer* line_buffer); }/* CVC4::parser namespace */ }/* CVC4 namespace */ diff --git a/src/parser/input.h b/src/parser/input.h index 7dce369c5..6aec8a2b1 100644 --- a/src/parser/input.h +++ b/src/parser/input.h @@ -140,9 +140,6 @@ public: /** Destructor. Frees the input stream and closes the input. */ virtual ~Input(); - /** Retrieve the remaining text in this input. */ - virtual std::string getUnparsedText() = 0; - /** Get the language that this Input is reading. */ virtual InputLanguage getLanguage() const throw() = 0; diff --git a/src/parser/line_buffer.cpp b/src/parser/line_buffer.cpp new file mode 100644 index 000000000..cdb06193e --- /dev/null +++ b/src/parser/line_buffer.cpp @@ -0,0 +1,88 @@ +/********************* */ +/*! \file line_buffer.cpp + ** \verbatim + ** Top contributors (to current version): + ** Andres Noetzli + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2016 by the authors listed in the file AUTHORS + ** in the top-level source directory) and their institutional affiliations. + ** All rights reserved. See the file COPYING in the top-level source + ** directory for licensing information.\endverbatim + ** + ** \brief The LineBuffer class stores lines from an input stream + ** + ** For each line, the class allocates a separate buffer. + **/ + +#include "parser/line_buffer.h" + +#include <cassert> +#include <cstring> +#include <iostream> +#include <string> + +namespace CVC4 { +namespace parser { + +LineBuffer::LineBuffer(std::istream* stream) : d_stream(stream) {} + +LineBuffer::~LineBuffer() { + for (size_t i = 0; i < d_lines.size(); i++) { + delete[] d_lines[i]; + } +} + +uint8_t* LineBuffer::getPtr(size_t line, size_t pos_in_line) { + if (!readToLine(line)) { + return NULL; + } + assert(pos_in_line < d_sizes[line]); + return d_lines[line] + pos_in_line; +} + +uint8_t* LineBuffer::getPtrWithOffset(size_t line, size_t pos_in_line, + size_t offset) { + if (!readToLine(line)) { + return NULL; + } + if (pos_in_line + offset >= d_sizes[line]) { + return getPtrWithOffset(line + 1, 0, + offset - (d_sizes[line] - pos_in_line - 1)); + } + assert(pos_in_line + offset < d_sizes[line]); + return d_lines[line] + pos_in_line + offset; +} + +bool LineBuffer::isPtrBefore(uint8_t* ptr, size_t line, size_t pos_in_line) { + for (ssize_t i = line; i >= 0; i--) { + // NOTE: std::less is guaranteed to give consistent results when comparing + // pointers of different arrays (in contrast to built-in comparison + // operators). + uint8_t* end = d_lines[i] + ((i == line) ? pos_in_line : d_sizes[i]); + if (std::less<uint8_t*>()(d_lines[i] - 1, ptr) && + std::less<uint8_t*>()(ptr, end)) { + return true; + } + } + return false; +} + +bool LineBuffer::readToLine(size_t line) { + while (line >= d_lines.size()) { + if (!(*d_stream)) { + return false; + } + + std::string line; + std::getline(*d_stream, line); + uint8_t* segment = new uint8_t[line.size() + 1]; + std::memcpy(segment, line.c_str(), line.size()); + segment[line.size()] = LineBuffer::NewLineChar; + d_lines.push_back(segment); + d_sizes.push_back(line.size() + 1); + } + return true; +} + +} // namespace parser +} // namespace CVC4 diff --git a/src/parser/line_buffer.h b/src/parser/line_buffer.h new file mode 100644 index 000000000..d7ccb5a10 --- /dev/null +++ b/src/parser/line_buffer.h @@ -0,0 +1,76 @@ +/********************* */ +/*! \file line_buffer.h + ** \verbatim + ** Top contributors (to current version): + ** Andres Noetzli + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2016 by the authors listed in the file AUTHORS + ** in the top-level source directory) and their institutional affiliations. + ** All rights reserved. See the file COPYING in the top-level source + ** directory for licensing information.\endverbatim + ** + ** \brief The LineBuffer class stores lines from an input stream + ** + ** Each line is guaranteed to be consecutive in memory. The content in + ** the line buffer can be addressed using line number and the position + ** within the line. + **/ + +#include "cvc4parser_private.h" + +#ifndef __CVC4__PARSER__LINE_BUFFER_H +#define __CVC4__PARSER__LINE_BUFFER_H + +#include <cstdlib> +#include <istream> +#include <vector> + +namespace CVC4 { +namespace parser { + +class LineBuffer { + public: + static const uint8_t NewLineChar = '\n'; + + LineBuffer(std::istream* stream); + ~LineBuffer(); + + /** + * Gets a pointer to a char at a specific line and position within that + * line. + */ + uint8_t* getPtr(size_t line, size_t pos_in_line); + + /** + * Gets a pointer to a char at an offset relative to a specific line and + * position within that line. + */ + uint8_t* getPtrWithOffset(size_t line, size_t pos_in_line, size_t offset); + + /** + * Tests whether a given pointer points to a location before a given + * line and position within that line. + */ + bool isPtrBefore(uint8_t* ptr, size_t line, size_t pos_in_line); + + private: + /** + * Reads lines up to a line number from the input if needed (it does + * nothing for the lines that were already read). Returns false if the end + * of the input stream has been reached and not all lines could be read. + */ + bool readToLine(size_t line); + + std::istream* d_stream; + // Each element in this vector corresponds to a line from the input stream. + // WARNING: not null-terminated. + std::vector<uint8_t*> d_lines; + // Each element in this vector corresponds to the length of a line from the + // input stream. + std::vector<size_t> d_sizes; +}; + +} // namespace parser +} // namespace CVC4 + +#endif /* __CVC4__PARSER__LINE_BUFFER_H */ diff --git a/src/parser/smt2/Smt2.g b/src/parser/smt2/Smt2.g index f01893a35..e693f1d57 100644 --- a/src/parser/smt2/Smt2.g +++ b/src/parser/smt2/Smt2.g @@ -3026,8 +3026,8 @@ DECLARE_DATATYPES_TOK : { PARSER_STATE->v2_6() }?'declare-datatypes'; DECLARE_CODATATYPES_2_5_TOK : { !PARSER_STATE->v2_6() }?'declare-codatatypes'; DECLARE_CODATATYPES_TOK : { PARSER_STATE->v2_6() }?'declare-codatatypes'; PAR_TOK : { PARSER_STATE->v2_6() }?'par'; -TESTER_TOK : { PARSER_STATE->v2_6() }?'is'; -MATCH_TOK : { PARSER_STATE->v2_6() }?'match'; +TESTER_TOK : { PARSER_STATE->v2_6() && PARSER_STATE->isTheoryEnabled(Smt2::THEORY_DATATYPES) }?'is'; +MATCH_TOK : { PARSER_STATE->v2_6() && PARSER_STATE->isTheoryEnabled(Smt2::THEORY_DATATYPES) }?'match'; GET_MODEL_TOK : 'get-model'; ECHO_TOK : 'echo'; REWRITE_RULE_TOK : 'assert-rewrite'; diff --git a/src/printer/smt2/smt2_printer.cpp b/src/printer/smt2/smt2_printer.cpp index 98993dba5..4dd6e73aa 100644 --- a/src/printer/smt2/smt2_printer.cpp +++ b/src/printer/smt2/smt2_printer.cpp @@ -61,14 +61,14 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, theory::SubstitutionMap::const_iterator i_end = lets.end(); for(; i != i_end; ++ i) { out << "(let (("; - toStream(out, (*i).second, toDepth, types); + toStream(out, (*i).second, toDepth, types, TypeNode::null()); out << ' '; - toStream(out, (*i).first, toDepth, types); + toStream(out, (*i).first, toDepth, types, TypeNode::null()); out << ")) "; } } Node body = dv.getDagifiedBody(); - toStream(out, body, toDepth, types); + toStream(out, body, toDepth, types, TypeNode::null()); if(!lets.empty()) { theory::SubstitutionMap::const_iterator i = lets.begin(); theory::SubstitutionMap::const_iterator i_end = lets.end(); @@ -77,7 +77,7 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, } } } else { - toStream(out, n, toDepth, types); + toStream(out, n, toDepth, types, TypeNode::null()); } } @@ -107,14 +107,30 @@ static bool stringifyRegexp(Node n, stringstream& ss) { return true; } +// force_nt is the type that n must have void Smt2Printer::toStream(std::ostream& out, TNode n, - int toDepth, bool types) const throw() { + int toDepth, bool types, TypeNode force_nt) const throw() { // null if(n.getKind() == kind::NULL_EXPR) { out << "null"; return; } + if( !force_nt.isNull() && n.getKind()!=kind::CONST_RATIONAL ){ + if( n.getType()!=force_nt ){ + if( force_nt.isReal() ){ + out << "(" << smtKindString( force_nt.isInteger() ? kind::TO_INTEGER : kind::TO_REAL) << " "; + toStream(out, n, toDepth, types, TypeNode::null()); + out << ")"; + }else{ + Node nn = NodeManager::currentNM()->mkNode(kind::APPLY_TYPE_ASCRIPTION, + NodeManager::currentNM()->mkConst(AscriptionType(force_nt.toType())), n ); + toStream(out, nn, toDepth, types, TypeNode::null()); + } + return; + } + } + // variable if(n.isVar()) { string s; @@ -216,10 +232,10 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, if(r < 0) { out << "-" << -r; }else{ - toStreamRational(out, r, false); + toStreamRational(out, r, !force_nt.isNull() && !force_nt.isInteger()); } }else{ - toStreamRational(out, r, false); + toStreamRational(out, r, !force_nt.isNull() && !force_nt.isInteger()); } // Rational r = n.getConst<Rational>(); // if(r < 0) { @@ -314,8 +330,8 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, } if(n.getNumChildren() != 0) { for(unsigned i = 0; i < n.getNumChildren(); ++i) { - out << ' '; - toStream(out, n[i], toDepth, types); + out << ' '; + toStream(out, n[i], toDepth, types, TypeNode::null()); } out << ')'; } @@ -324,6 +340,8 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, bool stillNeedToPrintParams = true; bool forceBinary = false; // force N-ary to binary when outputing children + bool parametricTypeChildren = false; // parametric operators that are (op t1 ... tn) where t1...tn must have same type + bool typeChildren = false; // operators (op t1...tn) where at least one of t1...tn may require a type cast e.g. Int -> Real // operator if(n.getNumChildren() != 0 && n.getKind() != kind::INST_PATTERN_LIST && @@ -334,7 +352,10 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, // builtin theory case kind::APPLY: break; case kind::EQUAL: - case kind::DISTINCT: out << smtKindString(k) << " "; break; + case kind::DISTINCT: + out << smtKindString(k) << " "; + parametricTypeChildren = true; + break; case kind::CHAIN: break; case kind::FUNCTION_TYPE: for(size_t i = 0; i < n.getNumChildren() - 1; ++i) { @@ -356,7 +377,7 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, case kind::ITE: out << smtKindString(k) << " "; break; // uf theory - case kind::APPLY_UF: break; + case kind::APPLY_UF: typeChildren = true; break; // arith theory case kind::PLUS: @@ -378,7 +399,10 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, case kind::IS_INTEGER: case kind::TO_INTEGER: case kind::TO_REAL: - case kind::POW: out << smtKindString(k) << " "; break; + case kind::POW: + parametricTypeChildren = true; + out << smtKindString(k) << " "; + break; case kind::DIVISIBLE: out << "(_ divisible " << n.getOperator().getConst<Divisible>().k << ")"; @@ -387,7 +411,7 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, // arrays theory case kind::SELECT: - case kind::STORE: + case kind::STORE: typeChildren = true; case kind::PARTIAL_SELECT_0: case kind::PARTIAL_SELECT_1: case kind::ARRAY_TYPE: out << smtKindString(k) << " "; break; @@ -397,7 +421,7 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, if(d_variant == z3str_variant) { out << "Concat "; for(unsigned i = 0; i < n.getNumChildren(); ++i) { - toStream(out, n[i], -1, types); + toStream(out, n[i], -1, types, TypeNode::null()); if(i + 1 < n.getNumChildren()) { out << ' '; } @@ -416,10 +440,10 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, stringstream ss; if(d_variant == z3str_variant && stringifyRegexp(n[1], ss)) { out << "= "; - toStream(out, n[0], -1, types); + toStream(out, n[0], -1, types, TypeNode::null()); out << " "; Node str = NodeManager::currentNM()->mkConst(String(ss.str())); - toStream(out, str, -1, types); + toStream(out, str, -1, types, TypeNode::null()); out << ")"; return; } @@ -508,7 +532,10 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, case kind::INTERSECTION: case kind::SETMINUS: case kind::SUBSET: - case kind::MEMBER: + parametricTypeChildren = true; + out << smtKindString(k) << " "; + break; + case kind::MEMBER: typeChildren = true; case kind::SET_TYPE: case kind::SINGLETON: case kind::COMPLEMENT:out << smtKindString(k) << " "; break; @@ -575,12 +602,12 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, return; } out << "(as "; - toStream(out, n[0], toDepth < 0 ? toDepth : toDepth - 1, types); + toStream(out, n[0], toDepth < 0 ? toDepth : toDepth - 1, types, TypeNode::null()); out << ' ' << (t.isFunctionLike() ? t.getRangeType() : t) << ')'; return; } break; - case kind::APPLY_CONSTRUCTOR: + case kind::APPLY_CONSTRUCTOR: typeChildren = true; case kind::APPLY_TESTER: case kind::APPLY_SELECTOR: case kind::APPLY_SELECTOR_TOTAL: @@ -660,7 +687,7 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, if(toDepth != 0) { if( d_variant==sygus_variant && n.getKind()==kind::APPLY_CONSTRUCTOR ){ std::stringstream ss; - toStream(ss, n.getOperator(), toDepth < 0 ? toDepth : toDepth - 1, types); + toStream(ss, n.getOperator(), toDepth < 0 ? toDepth : toDepth - 1, types, TypeNode::null()); std::string tmp = ss.str(); size_t pos = 0; if((pos = tmp.find("__Enum__", pos)) != std::string::npos){ @@ -672,14 +699,14 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, const Datatype& dt = Datatype::datatypeOf(n.getOperator().toExpr()); if( d_variant==smt2_6_variant ){ out << "(_ is "; - toStream(out, Node::fromExpr(dt[cindex].getConstructor()), toDepth < 0 ? toDepth : toDepth - 1, types); + toStream(out, Node::fromExpr(dt[cindex].getConstructor()), toDepth < 0 ? toDepth : toDepth - 1, types, TypeNode::null()); out << ")"; }else{ out << "is-"; - toStream(out, Node::fromExpr(dt[cindex].getConstructor()), toDepth < 0 ? toDepth : toDepth - 1, types); + toStream(out, Node::fromExpr(dt[cindex].getConstructor()), toDepth < 0 ? toDepth : toDepth - 1, types, TypeNode::null()); } }else{ - toStream(out, n.getOperator(), toDepth < 0 ? toDepth : toDepth - 1, types); + toStream(out, n.getOperator(), toDepth < 0 ? toDepth : toDepth - 1, types, TypeNode::null()); } } else { out << "(...)"; @@ -689,9 +716,63 @@ void Smt2Printer::toStream(std::ostream& out, TNode n, } } stringstream parens; + + // calculate the child type casts + std::map< unsigned, TypeNode > force_child_type; + if( parametricTypeChildren ){ + if( n.getNumChildren()>1 ){ + TypeNode force_ct = n[0].getType(); + bool do_force = false; + for(size_t i = 1; i < n.getNumChildren(); ++i ) { + TypeNode ct = n[i].getType(); + if( ct!=force_ct ){ + force_ct = TypeNode::leastCommonTypeNode( force_ct, ct ); + do_force = true; + } + } + if( do_force ){ + for(size_t i = 0; i < n.getNumChildren(); ++i ) { + force_child_type[i] = force_ct; + } + } + } + // operators that may require type casting + }else if( typeChildren ){ + if(n.getKind()==kind::SELECT){ + TypeNode indexType = TypeNode::leastCommonTypeNode( n[0].getType().getArrayIndexType(), n[1].getType() ); + TypeNode elemType = n[0].getType().getArrayConstituentType(); + force_child_type[0] = NodeManager::currentNM()->mkArrayType( indexType, elemType ); + force_child_type[1] = indexType; + }else if(n.getKind()==kind::STORE){ + TypeNode indexType = TypeNode::leastCommonTypeNode( n[0].getType().getArrayIndexType(), n[1].getType() ); + TypeNode elemType = TypeNode::leastCommonTypeNode( n[0].getType().getArrayConstituentType(), n[2].getType() ); + force_child_type[0] = NodeManager::currentNM()->mkArrayType( indexType, elemType ); + force_child_type[1] = indexType; + force_child_type[2] = elemType; + }else if(n.getKind()==kind::MEMBER){ + TypeNode elemType = TypeNode::leastCommonTypeNode( n[0].getType(), n[1].getType().getSetElementType() ); + force_child_type[0] = elemType; + force_child_type[1] = NodeManager::currentNM()->mkSetType( elemType ); + }else{ + // APPLY_UF, APPLY_CONSTRUCTOR, etc. + Assert( n.hasOperator() ); + TypeNode opt = n.getOperator().getType(); + Assert( opt.getNumChildren() == n.getNumChildren() + 1 ); + for(size_t i = 0; i < n.getNumChildren(); ++i ) { + force_child_type[i] = opt[i]; + } + } + } + for(size_t i = 0, c = 1; i < n.getNumChildren(); ) { if(toDepth != 0) { - toStream(out, n[i], toDepth < 0 ? toDepth : toDepth - c, types); + Node cn = n[i]; + std::map< unsigned, TypeNode >::iterator itfc = force_child_type.find( i ); + if( itfc!=force_child_type.end() ){ + toStream(out, cn, toDepth < 0 ? toDepth : toDepth - c, types, itfc->second); + }else{ + toStream(out, cn, toDepth < 0 ? toDepth : toDepth - c, types, TypeNode::null()); + } } else { out << "(...)"; } diff --git a/src/printer/smt2/smt2_printer.h b/src/printer/smt2/smt2_printer.h index d73f11b59..eeba0b12a 100644 --- a/src/printer/smt2/smt2_printer.h +++ b/src/printer/smt2/smt2_printer.h @@ -38,7 +38,7 @@ enum Variant { class Smt2Printer : public CVC4::Printer { Variant d_variant; - void toStream(std::ostream& out, TNode n, int toDepth, bool types) const throw(); + void toStream(std::ostream& out, TNode n, int toDepth, bool types, TypeNode nt) const throw(); void toStream(std::ostream& out, const Model& m, const Command* c) const throw(); public: Smt2Printer(Variant variant = no_variant) : d_variant(variant) { } diff --git a/src/proof/sat_proof.h b/src/proof/sat_proof.h index 5691d1bd2..36de6278a 100644 --- a/src/proof/sat_proof.h +++ b/src/proof/sat_proof.h @@ -29,6 +29,7 @@ #include <vector> #include "context/cdhashmap.h" +#include "context/cdmaybe.h" #include "expr/expr.h" #include "proof/clause_id.h" #include "proof/proof_manager.h" @@ -349,8 +350,7 @@ class TSatProof { IdCRefMap d_temp_idClause; // unit conflict - ClauseId d_unitConflictId; - bool d_storedUnitConflict; + context::CDMaybe<ClauseId> d_unitConflictId; ClauseId d_trueLit; ClauseId d_falseLit; diff --git a/src/proof/sat_proof_implementation.h b/src/proof/sat_proof_implementation.h index eb4e04d13..6cb10450a 100644 --- a/src/proof/sat_proof_implementation.h +++ b/src/proof/sat_proof_implementation.h @@ -218,8 +218,7 @@ TSatProof<Solver>::TSatProof(Solver* solver, context::Context* context, d_nullId(-2), d_temp_clauseId(), d_temp_idClause(), - d_unitConflictId(), - d_storedUnitConflict(false), + d_unitConflictId(context), d_trueLit(ClauseIdUndef), d_falseLit(ClauseIdUndef), d_name(name), @@ -867,12 +866,11 @@ template <class Solver> ClauseId TSatProof<Solver>::storeUnitConflict( typename Solver::TLit conflict_lit, ClauseKind kind) { Debug("cores") << "STORE UNIT CONFLICT" << std::endl; - Assert(!d_storedUnitConflict); - d_unitConflictId = registerUnitClause(conflict_lit, kind); - d_storedUnitConflict = true; - Debug("proof:sat:detailed") << "storeUnitConflict " << d_unitConflictId + Assert(!d_unitConflictId.isSet()); + d_unitConflictId.set(registerUnitClause(conflict_lit, kind)); + Debug("proof:sat:detailed") << "storeUnitConflict " << d_unitConflictId.get() << "\n"; - return d_unitConflictId; + return d_unitConflictId.get(); } template <class Solver> @@ -881,8 +879,8 @@ void TSatProof<Solver>::finalizeProof(typename Solver::TCRef conflict_ref) { Assert(conflict_ref != Solver::TCRef_Undef); ClauseId conflict_id; if (conflict_ref == Solver::TCRef_Lazy) { - Assert(d_storedUnitConflict); - conflict_id = d_unitConflictId; + Assert(d_unitConflictId.isSet()); + conflict_id = d_unitConflictId.get(); ResChain<Solver>* res = new ResChain<Solver>(conflict_id); typename Solver::TLit lit = d_idUnit[conflict_id]; @@ -892,7 +890,7 @@ void TSatProof<Solver>::finalizeProof(typename Solver::TCRef conflict_ref) { return; } else { - Assert(!d_storedUnitConflict); + Assert(!d_unitConflictId.isSet()); conflict_id = registerClause(conflict_ref, LEARNT); // FIXME } diff --git a/src/theory/arrays/theory_arrays.cpp b/src/theory/arrays/theory_arrays.cpp index 2c7418a77..e712a51b6 100644 --- a/src/theory/arrays/theory_arrays.cpp +++ b/src/theory/arrays/theory_arrays.cpp @@ -1704,7 +1704,7 @@ void TheoryArrays::mergeArrays(TNode a, TNode b) // so we take its representative to be safe. a = d_equalityEngine.getRepresentative(a); Assert(d_equalityEngine.getRepresentative(b) == a); - Trace("arrays-merge") << spaces(getSatContext()->getLevel()) << "Arrays::merge: " << a << "," << b << ")\n"; + Trace("arrays-merge") << spaces(getSatContext()->getLevel()) << "Arrays::merge: (" << a << ", " << b << ")\n"; if (options::arraysLazyRIntro1() && !options::arraysWeakEquivalence()) { checkRIntro1(a, b); diff --git a/src/theory/arrays/theory_arrays.h b/src/theory/arrays/theory_arrays.h index 574702368..48da4c681 100644 --- a/src/theory/arrays/theory_arrays.h +++ b/src/theory/arrays/theory_arrays.h @@ -309,7 +309,6 @@ class TheoryArrays : public Theory { Debug("arrays::propagate") << spaces(d_arrays.getSatContext()->getLevel()) << "NotifyClass::eqNotifyTriggerTermEquality(" << t1 << ", " << t2 << ", " << (value ? "true" : "false") << ")" << std::endl; if (value) { if (t1.getType().isArray()) { - d_arrays.mergeArrays(t1, t2); if (!d_arrays.isShared(t1) || !d_arrays.isShared(t2)) { return true; } @@ -334,7 +333,11 @@ class TheoryArrays : public Theory { void eqNotifyNewClass(TNode t) { } void eqNotifyPreMerge(TNode t1, TNode t2) { } - void eqNotifyPostMerge(TNode t1, TNode t2) { } + void eqNotifyPostMerge(TNode t1, TNode t2) { + if (t1.getType().isArray()) { + d_arrays.mergeArrays(t1, t2); + } + } void eqNotifyDisequal(TNode t1, TNode t2, TNode reason) { } }; diff --git a/src/theory/bv/theory_bv_rewrite_rules.h b/src/theory/bv/theory_bv_rewrite_rules.h index 5957c641d..39e8e38cd 100644 --- a/src/theory/bv/theory_bv_rewrite_rules.h +++ b/src/theory/bv/theory_bv_rewrite_rules.h @@ -56,7 +56,7 @@ enum RewriteRuleId { SubEliminate, SltEliminate, SleEliminate, - UleEliminate, + UleEliminate, CompEliminate, RepeatEliminate, RotateLeftEliminate, @@ -75,7 +75,7 @@ enum RewriteRuleId { /// ground term evaluation EvalEquals, - EvalConcat, + EvalConcat, EvalAnd, EvalOr, EvalXor, @@ -90,7 +90,7 @@ enum RewriteRuleId { EvalUlt, EvalUltBv, EvalUle, - EvalExtract, + EvalExtract, EvalSignExtend, EvalRotateLeft, EvalRotateRight, @@ -133,18 +133,18 @@ enum RewriteRuleId { ExtractMultLeadingBit, NegIdemp, UdivPow2, + UdivZero, UdivOne, - UdivSelf, UremPow2, UremOne, UremSelf, ShiftZero, UltOne, - SltZero, + SltZero, ZeroUlt, MergeSignExtend, - + /// normalization rules ExtractBitwise, ExtractNot, @@ -156,9 +156,9 @@ enum RewriteRuleId { NegSub, NegPlus, NotConcat, - NotAnd, // not sure why this would help (not done) - NotOr, // not sure why this would help (not done) - NotXor, // not sure why this would help (not done) + NotAnd, // not sure why this would help (not done) + NotOr, // not sure why this would help (not done) + NotXor, // not sure why this would help (not done) FlattenAssocCommut, FlattenAssocCommutNoDuplicates, PlusCombineLikeTerms, @@ -178,7 +178,6 @@ enum RewriteRuleId { IsPowerOfTwo }; - inline std::ostream& operator << (std::ostream& out, RewriteRuleId ruleId) { switch (ruleId) { case EmptyRule: out << "EmptyRule"; return out; @@ -272,8 +271,10 @@ inline std::ostream& operator << (std::ostream& out, RewriteRuleId ruleId) { case ExtractMultLeadingBit : out << "ExtractMultLeadingBit"; return out; case NegIdemp : out << "NegIdemp"; return out; case UdivPow2 : out << "UdivPow2"; return out; + case UdivZero: + out << "UdivZero"; + return out; case UdivOne : out << "UdivOne"; return out; - case UdivSelf : out << "UdivSelf"; return out; case UremPow2 : out << "UremPow2"; return out; case UremOne : out << "UremOne"; return out; case UremSelf : out << "UremSelf"; return out; @@ -501,8 +502,8 @@ struct AllRewriteRules { RewriteRule<ExtractMultLeadingBit> rule88; RewriteRule<NegIdemp> rule91; RewriteRule<UdivPow2> rule92; - RewriteRule<UdivOne> rule93; - RewriteRule<UdivSelf> rule94; + RewriteRule<UdivZero> rule93; + RewriteRule<UdivOne> rule94; RewriteRule<UremPow2> rule95; RewriteRule<UremOne> rule96; RewriteRule<UremSelf> rule97; diff --git a/src/theory/bv/theory_bv_rewrite_rules_simplification.h b/src/theory/bv/theory_bv_rewrite_rules_simplification.h index 871380467..c49319387 100644 --- a/src/theory/bv/theory_bv_rewrite_rules_simplification.h +++ b/src/theory/bv/theory_bv_rewrite_rules_simplification.h @@ -908,39 +908,39 @@ Node RewriteRule<UdivPow2>::apply(TNode node) { } /** - * UdivOne + * UdivZero * - * (a udiv 1) ==> a + * (a udiv 0) ==> 111...1 */ -template<> inline -bool RewriteRule<UdivOne>::applies(TNode node) { +template <> +inline bool RewriteRule<UdivZero>::applies(TNode node) { return (node.getKind() == kind::BITVECTOR_UDIV_TOTAL && - node[1] == utils::mkConst(utils::getSize(node), 1)); + node[1] == utils::mkConst(utils::getSize(node), 0)); } -template<> inline -Node RewriteRule<UdivOne>::apply(TNode node) { - Debug("bv-rewrite") << "RewriteRule<UdivOne>(" << node << ")" << std::endl; - return node[0]; +template <> +inline Node RewriteRule<UdivZero>::apply(TNode node) { + Debug("bv-rewrite") << "RewriteRule<UdivZero>(" << node << ")" << std::endl; + return utils::mkOnes(utils::getSize(node)); } /** - * UdivSelf + * UdivOne * - * (a udiv a) ==> 1 + * (a udiv 1) ==> a */ -template<> inline -bool RewriteRule<UdivSelf>::applies(TNode node) { +template <> +inline bool RewriteRule<UdivOne>::applies(TNode node) { return (node.getKind() == kind::BITVECTOR_UDIV_TOTAL && - node[0] == node[1]); + node[1] == utils::mkConst(utils::getSize(node), 1)); } -template<> inline -Node RewriteRule<UdivSelf>::apply(TNode node) { - Debug("bv-rewrite") << "RewriteRule<UdivSelf>(" << node << ")" << std::endl; - return utils::mkConst(utils::getSize(node), 1); +template <> +inline Node RewriteRule<UdivOne>::apply(TNode node) { + Debug("bv-rewrite") << "RewriteRule<UdivOne>(" << node << ")" << std::endl; + return node[0]; } /** diff --git a/src/theory/bv/theory_bv_rewriter.cpp b/src/theory/bv/theory_bv_rewriter.cpp index e40612ba6..df21093c1 100644 --- a/src/theory/bv/theory_bv_rewriter.cpp +++ b/src/theory/bv/theory_bv_rewriter.cpp @@ -439,11 +439,9 @@ RewriteResponse TheoryBVRewriter::RewriteUdivTotal(TNode node, bool prerewrite){ return RewriteResponse(REWRITE_AGAIN_FULL, resultNode); } - resultNode = LinearRewriteStrategy - < RewriteRule<EvalUdiv>, - RewriteRule<UdivOne>, - RewriteRule<UdivSelf> - >::apply(node); + resultNode = + LinearRewriteStrategy<RewriteRule<EvalUdiv>, RewriteRule<UdivZero>, + RewriteRule<UdivOne> >::apply(node); return RewriteResponse(REWRITE_DONE, resultNode); } diff --git a/src/theory/datatypes/theory_datatypes.cpp b/src/theory/datatypes/theory_datatypes.cpp index 4ca631184..1a466ff8a 100644 --- a/src/theory/datatypes/theory_datatypes.cpp +++ b/src/theory/datatypes/theory_datatypes.cpp @@ -1222,6 +1222,42 @@ void TheoryDatatypes::addConstructor( Node c, EqcInfo* eqc, Node n ){ eqc->d_constructor.set( c ); } +Node TheoryDatatypes::removeUninterpretedConstants( Node n, std::map< Node, Node >& visited ){ + std::map< Node, Node >::iterator it = visited.find( n ); + if( it==visited.end() ){ + Node ret = n; + if( n.getKind()==UNINTERPRETED_CONSTANT ){ + std::map< Node, Node >::iterator itu = d_uc_to_fresh_var.find( n ); + if( itu==d_uc_to_fresh_var.end() ){ + Node k = NodeManager::currentNM()->mkSkolem( "w", n.getType(), "Skolem for wrongly applied selector." ); + d_uc_to_fresh_var[n] = k; + ret = k; + }else{ + ret = itu->second; + } + }else if( n.getNumChildren()>0 ){ + std::vector< Node > children; + if( n.getMetaKind() == kind::metakind::PARAMETERIZED ){ + children.push_back( n.getOperator() ); + } + bool childChanged = false; + for( unsigned i=0; i<n.getNumChildren(); i++ ){ + Node nc = removeUninterpretedConstants( n[i], visited ); + childChanged = childChanged || nc!=n[i]; + children.push_back( nc ); + } + if( childChanged ){ + ret = NodeManager::currentNM()->mkNode( n.getKind(), children ); + } + } + visited[n] = ret; + return ret; + }else{ + return it->second; + } +} + + void TheoryDatatypes::collapseSelector( Node s, Node c ) { Assert( c.getKind()==APPLY_CONSTRUCTOR ); Trace("dt-collapse-sel") << "collapse selector : " << s << " " << c << std::endl; @@ -1268,8 +1304,16 @@ void TheoryDatatypes::collapseSelector( Node s, Node c ) { } if( !r.isNull() ){ Node rr = Rewriter::rewrite( r ); - if( use_s!=rr ){ - Node eq = use_s.eqNode( rr ); + Node rrs = rr; + if( wrong ){ + // we have inference S_i( C_j( t ) ) = t' for i != j, where t' is result of mkGroundTerm. + // we must eliminate uninterpreted constants for datatypes that have uninterpreted sort subfields, + // since uninterpreted constants should not appear in lemmas + std::map< Node, Node > visited; + rrs = removeUninterpretedConstants( rr, visited ); + } + if( use_s!=rrs ){ + Node eq = use_s.eqNode( rrs ); Node eq_exp; if( options::dtRefIntro() ){ eq_exp = d_true; @@ -1654,19 +1698,6 @@ void TheoryDatatypes::collectTerms( Node n ) { } } -void TheoryDatatypes::processNewTerm( Node n ){ - Trace("dt-terms") << "Created term : " << n << std::endl; - //see if it is rewritten to be something different - Node rn = Rewriter::rewrite( n ); - if( rn!=n && !areEqual( rn, n ) ){ - Node eq = rn.eqNode( n ); - d_pending.push_back( eq ); - d_pending_exp[ eq ] = d_true; - Trace("datatypes-infer") << "DtInfer : rewrite : " << eq << std::endl; - d_infer.push_back( eq ); - } -} - Node TheoryDatatypes::getInstantiateCons( Node n, const Datatype& dt, int index ){ std::map< int, Node >::iterator it = d_inst_map[n].find( index ); if( it!=d_inst_map[n].end() ){ diff --git a/src/theory/datatypes/theory_datatypes.h b/src/theory/datatypes/theory_datatypes.h index 6a26352ad..98d8d53b1 100644 --- a/src/theory/datatypes/theory_datatypes.h +++ b/src/theory/datatypes/theory_datatypes.h @@ -192,7 +192,8 @@ private: /** sygus utilities */ SygusSplit * d_sygus_split; SygusSymBreak * d_sygus_sym_break; - + /** uninterpreted constant to variable map */ + std::map< Node, Node > d_uc_to_fresh_var; private: /** singleton lemmas (for degenerate co-datatype case) */ std::map< TypeNode, Node > d_singleton_lemma[2]; @@ -284,6 +285,8 @@ private: void merge( Node t1, Node t2 ); /** collapse selector, s is of the form sel( n ) where n = c */ void collapseSelector( Node s, Node c ); + /** remove uninterpreted constants */ + Node removeUninterpretedConstants( Node n, std::map< Node, Node >& visited ); /** for checking if cycles exist */ void checkCycles(); Node searchForCycle( TNode n, TNode on, @@ -302,8 +305,6 @@ private: void collectTerms( Node n ); /** get instantiate cons */ Node getInstantiateCons( Node n, const Datatype& dt, int index ); - /** process new term that was created internally */ - void processNewTerm( Node n ); /** check instantiate */ void instantiate( EqcInfo* eqc, Node n ); /** must communicate fact */ diff --git a/src/theory/quantifiers/first_order_model.cpp b/src/theory/quantifiers/first_order_model.cpp index 084912f5a..612646b42 100644 --- a/src/theory/quantifiers/first_order_model.cpp +++ b/src/theory/quantifiers/first_order_model.cpp @@ -734,8 +734,7 @@ Node FirstOrderModelFmc::getFunctionValue(Node op, const char* argPrefix ) { if( !isStar(cond[j][1]) ){ children.push_back( NodeManager::currentNM()->mkNode( LT, vars[j], cond[j][1] ) ); } - }else if ( !isStar(cond[j]) && //handle the case where there are 0 or 1 ground eqc of this type - d_rep_set.d_type_reps.find( tn )!=d_rep_set.d_type_reps.end() && d_rep_set.d_type_reps[ tn ].size()>1 ){ + }else if( !isStar(cond[j]) ){ Node c = getRepresentative( cond[j] ); c = getRepresentative( c ); children.push_back( NodeManager::currentNM()->mkNode( EQUAL, vars[j], c ) ); diff --git a/src/theory/quantifiers/inst_match.cpp b/src/theory/quantifiers/inst_match.cpp index 12e15d353..9a3fe379c 100644 --- a/src/theory/quantifiers/inst_match.cpp +++ b/src/theory/quantifiers/inst_match.cpp @@ -129,6 +129,7 @@ void InstMatch::setValue( int i, TNode n ) { } bool InstMatch::set( QuantifiersEngine* qe, int i, TNode n ) { + Assert( i>=0 ); if( !d_vals[i].isNull() ){ if( qe->getEqualityQuery()->areEqual( d_vals[i], n ) ){ return true; diff --git a/src/theory/quantifiers/inst_match_generator.cpp b/src/theory/quantifiers/inst_match_generator.cpp index 889fe667e..8d7b321c8 100644 --- a/src/theory/quantifiers/inst_match_generator.cpp +++ b/src/theory/quantifiers/inst_match_generator.cpp @@ -955,8 +955,10 @@ void InstMatchGeneratorSimple::addInstantiations( InstMatch& m, QuantifiersEngin Debug("simple-trigger") << "Actual term is " << t << std::endl; //convert to actual used terms for( std::map< int, int >::iterator it = d_var_num.begin(); it != d_var_num.end(); ++it ){ - Debug("simple-trigger") << "...set " << it->second << " " << t[it->first] << std::endl; - m.setValue( it->second, t[it->first] ); + if( it->second>=0 ){ + Debug("simple-trigger") << "...set " << it->second << " " << t[it->first] << std::endl; + m.setValue( it->second, t[it->first] ); + } } if( qe->addInstantiation( d_f, m ) ){ addedLemmas++; diff --git a/src/theory/quantifiers/inst_strategy_cbqi.cpp b/src/theory/quantifiers/inst_strategy_cbqi.cpp index 88f8e2484..58bebef35 100644 --- a/src/theory/quantifiers/inst_strategy_cbqi.cpp +++ b/src/theory/quantifiers/inst_strategy_cbqi.cpp @@ -496,21 +496,49 @@ bool InstStrategyCbqi::hasNonCbqiOperator( Node n, std::map< Node, bool >& visit } return false; } -int InstStrategyCbqi::hasNonCbqiVariable( Node q ){ - int hmin = 1; - for( unsigned i=0; i<q[0].getNumChildren(); i++ ){ - TypeNode tn = q[0][i].getType(); - int handled = -1; + +// -1 : not cbqi sort, 0 : cbqi sort, 1 : cbqi sort regardless of quantifier body +int InstStrategyCbqi::isCbqiSort( TypeNode tn, std::map< TypeNode, int >& visited ) { + std::map< TypeNode, int >::iterator itv = visited.find( tn ); + if( itv==visited.end() ){ + visited[tn] = 0; + int ret = -1; if( tn.isInteger() || tn.isReal() || tn.isBoolean() || tn.isBitVector() ){ - handled = 0; + ret = 0; }else if( tn.isDatatype() ){ - handled = 0; + ret = 1; + const Datatype& dt = ((DatatypeType)tn.toType()).getDatatype(); + for( unsigned i=0; i<dt.getNumConstructors(); i++ ){ + for( unsigned j=0; j<dt[i].getNumArgs(); j++ ){ + TypeNode crange = TypeNode::fromType( ((SelectorType)dt[i][j].getType()).getRangeType() ); + int cret = isCbqiSort( crange, visited ); + if( cret==-1 ){ + visited[tn] = -1; + return -1; + }else if( cret<ret ){ + ret = cret; + } + } + } }else if( tn.isSort() ){ QuantEPR * qepr = d_quantEngine->getQuantEPR(); if( qepr!=NULL ){ - handled = qepr->isEPR( tn ) ? 1 : -1; + ret = qepr->isEPR( tn ) ? 1 : -1; } } + visited[tn] = ret; + return ret; + }else{ + return itv->second; + } +} + +int InstStrategyCbqi::hasNonCbqiVariable( Node q ){ + int hmin = 1; + for( unsigned i=0; i<q[0].getNumChildren(); i++ ){ + TypeNode tn = q[0][i].getType(); + std::map< TypeNode, int > visited; + int handled = isCbqiSort( tn, visited ); if( handled==-1 ){ return -1; }else if( handled<hmin ){ diff --git a/src/theory/quantifiers/inst_strategy_cbqi.h b/src/theory/quantifiers/inst_strategy_cbqi.h index 2cd5f6e1c..6c2dc9275 100644 --- a/src/theory/quantifiers/inst_strategy_cbqi.h +++ b/src/theory/quantifiers/inst_strategy_cbqi.h @@ -58,6 +58,7 @@ protected: /** helper functions */ int hasNonCbqiVariable( Node q ); bool hasNonCbqiOperator( Node n, std::map< Node, bool >& visited ); + int isCbqiSort( TypeNode tn, std::map< TypeNode, int >& visited ); /** get next decision request with dependency checking */ Node getNextDecisionRequestProc( Node q, std::map< Node, bool >& proc ); /** process functions */ diff --git a/src/theory/quantifiers/inst_strategy_e_matching.cpp b/src/theory/quantifiers/inst_strategy_e_matching.cpp index a197e057e..2cef4f6a1 100644 --- a/src/theory/quantifiers/inst_strategy_e_matching.cpp +++ b/src/theory/quantifiers/inst_strategy_e_matching.cpp @@ -671,7 +671,9 @@ bool FullSaturation::process( Node f, bool fullEffort ){ Trace("inst-alg") << "-> Ground term instantiate " << f << "..." << std::endl; } Assert( rd!=NULL ); + Trace("inst-alg-debug") << "Compute relevant domain..." << std::endl; rd->compute(); + Trace("inst-alg-debug") << "...finished" << std::endl; unsigned final_max_i = 0; std::vector< unsigned > maxs; std::vector< bool > max_zero; diff --git a/src/theory/quantifiers/relevant_domain.cpp b/src/theory/quantifiers/relevant_domain.cpp index f7bac23e2..63231dec7 100644 --- a/src/theory/quantifiers/relevant_domain.cpp +++ b/src/theory/quantifiers/relevant_domain.cpp @@ -152,6 +152,7 @@ void RelevantDomain::compute(){ } void RelevantDomain::computeRelevantDomain( Node q, Node n, bool hasPol, bool pol ) { + Trace("rel-dom-debug") << "Compute relevant domain " << n << "..." << std::endl; Node op = d_qe->getTermDatabase()->getMatchOperator( n ); for( unsigned i=0; i<n.getNumChildren(); i++ ){ if( !op.isNull() ){ @@ -191,6 +192,7 @@ void RelevantDomain::computeRelevantDomain( Node q, Node n, bool hasPol, bool po } } } + Trace("rel-dom-debug") << "...finished Compute relevant domain " << n << std::endl; } void RelevantDomain::computeRelevantDomainOpCh( RDomain * rf, Node n ) { @@ -238,43 +240,45 @@ void RelevantDomain::computeRelevantDomainLit( Node q, bool hasPol, bool pol, No d_rel_dom_lit[hasPol][pol][n].d_rd[1] = NULL; }else{ //solve the inequality for one/two variables, if possible - std::map< Node, Node > msum; - if( QuantArith::getMonomialSumLit( n, msum ) ){ - Node var; - Node var2; - bool hasNonVar = false; - for( std::map< Node, Node >::iterator it = msum.begin(); it != msum.end(); ++it ){ - if( !it->first.isNull() && it->first.getKind()==INST_CONSTANT ){ - if( var.isNull() ){ - var = it->first; - }else if( var2.isNull() ){ - var2 = it->first; + if( n[0].getType().isReal() ){ + std::map< Node, Node > msum; + if( QuantArith::getMonomialSumLit( n, msum ) ){ + Node var; + Node var2; + bool hasNonVar = false; + for( std::map< Node, Node >::iterator it = msum.begin(); it != msum.end(); ++it ){ + if( !it->first.isNull() && it->first.getKind()==INST_CONSTANT ){ + if( var.isNull() ){ + var = it->first; + }else if( var2.isNull() ){ + var2 = it->first; + }else{ + hasNonVar = true; + } }else{ hasNonVar = true; } - }else{ - hasNonVar = true; } - } - if( !var.isNull() ){ - if( var2.isNull() ){ - //single variable solve - Node veq_c; - Node val; - int ires = QuantArith::isolate( var, msum, veq_c, val, n.getKind() ); - if( ires!=0 ){ - if( veq_c.isNull() ){ - r_add = val; - varLhs = (ires==1); - d_rel_dom_lit[hasPol][pol][n].d_rd[0] = getRDomain( q, var.getAttribute(InstVarNumAttribute()), false ); - d_rel_dom_lit[hasPol][pol][n].d_rd[1] = NULL; + if( !var.isNull() ){ + if( var2.isNull() ){ + //single variable solve + Node veq_c; + Node val; + int ires = QuantArith::isolate( var, msum, veq_c, val, n.getKind() ); + if( ires!=0 ){ + if( veq_c.isNull() ){ + r_add = val; + varLhs = (ires==1); + d_rel_dom_lit[hasPol][pol][n].d_rd[0] = getRDomain( q, var.getAttribute(InstVarNumAttribute()), false ); + d_rel_dom_lit[hasPol][pol][n].d_rd[1] = NULL; + } } + }else if( !hasNonVar ){ + //merge the domains + d_rel_dom_lit[hasPol][pol][n].d_rd[0] = getRDomain( q, var.getAttribute(InstVarNumAttribute()), false ); + d_rel_dom_lit[hasPol][pol][n].d_rd[1] = getRDomain( q, var2.getAttribute(InstVarNumAttribute()), false ); + d_rel_dom_lit[hasPol][pol][n].d_merge = true; } - }else if( !hasNonVar ){ - //merge the domains - d_rel_dom_lit[hasPol][pol][n].d_rd[0] = getRDomain( q, var.getAttribute(InstVarNumAttribute()), false ); - d_rel_dom_lit[hasPol][pol][n].d_rd[1] = getRDomain( q, var2.getAttribute(InstVarNumAttribute()), false ); - d_rel_dom_lit[hasPol][pol][n].d_merge = true; } } } diff --git a/src/theory/theory_engine.cpp b/src/theory/theory_engine.cpp index 4d2998c68..f99de0c3b 100644 --- a/src/theory/theory_engine.cpp +++ b/src/theory/theory_engine.cpp @@ -1703,11 +1703,14 @@ void TheoryEngine::ensureLemmaAtoms(const std::vector<TNode>& atoms, theory::The assertToTheory(eq.notNode(), eqNormalized.notNode(), /** to */ atomsTo, /** Sat solver */ theory::THEORY_SAT_SOLVER); } continue; + }else if( eqNormalized.getKind() != kind::EQUAL){ + Assert( eqNormalized.getKind()==kind::BOOLEAN_TERM_VARIABLE || + ( eqNormalized.getKind()==kind::NOT && eqNormalized[0].getKind()==kind::BOOLEAN_TERM_VARIABLE ) ); + // this happens for Boolean term equalities V = true that are rewritten to V, we should skip + // TODO : revisit this + continue; } - Assert(eqNormalized.getKind() == kind::EQUAL); - - // If the normalization did the just flips, keep the flip if (eqNormalized[0] == eq[1] && eqNormalized[1] == eq[0]) { eq = eqNormalized; diff --git a/test/regress/regress0/Makefile.am b/test/regress/regress0/Makefile.am index 1d2cc9f45..9a16f68ca 100644 --- a/test/regress/regress0/Makefile.am +++ b/test/regress/regress0/Makefile.am @@ -68,7 +68,8 @@ SMT2_TESTS = \ hung10_itesdk_output2.smt2 \ hung10_itesdk_output1.smt2 \ hung13sdk_output2.smt2 \ - declare-funs.smt2 + declare-funs.smt2 \ + declare-fun-is-match.smt2 # Regression tests for PL inputs CVC_TESTS = \ @@ -178,6 +179,7 @@ BUG_TESTS = \ bug596.cvc \ bug596b.cvc \ bug605.cvc \ + bug639.smt2 \ bt-test-00.smt2 \ bt-test-01.smt2 #bug590.smt2 @@ -188,9 +190,7 @@ TESTS = $(SMT_TESTS) $(SMT2_TESTS) $(CVC_TESTS) $(TPTP_TESTS) $(BUG_TESTS) # we have a minimized version still getting tested # bug639 -- still fails, reopened bug DISABLED_TESTS = \ - bug512.smt2 \ - bug639.smt2 - + bug512.smt2 EXTRA_DIST = $(TESTS) \ simplification_bug4.smt2.expect \ diff --git a/test/regress/regress0/arith/mult.02.smt2 b/test/regress/regress0/arith/mult.02.smt2 index 54b876d38..57167fc76 100644 --- a/test/regress/regress0/arith/mult.02.smt2 +++ b/test/regress/regress0/arith/mult.02.smt2 @@ -1,5 +1,5 @@ ; EXPECT: (error "A non-linear fact was asserted to arithmetic in a linear logic. -; EXPECT: The fact in question: (>= (* (- 1) (* n n)) (- 1)) +; EXPECT: The fact in question: (>= (* (- 1.0) (* n n)) (- 1.0)) ; EXPECT: ") ; EXIT: 1 (set-logic QF_LRA) diff --git a/test/regress/regress0/bug639.smt2 b/test/regress/regress0/bug639.smt2 index 9e31e75cd..907568d73 100644 --- a/test/regress/regress0/bug639.smt2 +++ b/test/regress/regress0/bug639.smt2 @@ -1,4 +1,4 @@ -(set-logic QF_AUFLIA) +(set-logic QF_AUFNIA) (set-info :status unsat) (declare-fun i () Int) (declare-fun j () Int) diff --git a/test/regress/regress0/declare-fun-is-match.smt2 b/test/regress/regress0/declare-fun-is-match.smt2 new file mode 100644 index 000000000..d9387208f --- /dev/null +++ b/test/regress/regress0/declare-fun-is-match.smt2 @@ -0,0 +1,9 @@ +; EXPECT: sat +(set-info :smt-lib-version 2.6) +(set-logic UFIDL) +(set-info :status sat) +(declare-fun match (Int Int) Int) +(declare-fun is (Int Int) Int) +(assert (= match is)) +(check-sat) +(exit) diff --git a/test/regress/regress0/push-pop/Makefile.am b/test/regress/regress0/push-pop/Makefile.am index 262132779..197f81d63 100644 --- a/test/regress/regress0/push-pop/Makefile.am +++ b/test/regress/regress0/push-pop/Makefile.am @@ -48,7 +48,8 @@ BUG_TESTS = \ inc-define.smt2 \ bug765.smt2 \ bug691.smt2 \ - bug694-Unapply1.scala-0.smt2 + bug694-Unapply1.scala-0.smt2 \ + simple_unsat_cores.smt2 TESTS = $(SMT_TESTS) $(SMT2_TESTS) $(CVC_TESTS) $(BUG_TESTS) diff --git a/test/regress/regress0/push-pop/simple_unsat_cores.smt2 b/test/regress/regress0/push-pop/simple_unsat_cores.smt2 new file mode 100644 index 000000000..e85a546d8 --- /dev/null +++ b/test/regress/regress0/push-pop/simple_unsat_cores.smt2 @@ -0,0 +1,10 @@ +; COMMAND-LINE: --incremental +; EXPECT: unsat +; EXPECT: unsat +(set-logic UF) +(push 1) +(assert false) +(check-sat) +(pop 1) +(assert false) +(check-sat) diff --git a/test/regress/regress0/quantifiers/Makefile.am b/test/regress/regress0/quantifiers/Makefile.am index eb28efdf6..c5a81c960 100644 --- a/test/regress/regress0/quantifiers/Makefile.am +++ b/test/regress/regress0/quantifiers/Makefile.am @@ -91,7 +91,8 @@ TESTS = \ mix-complete-strat.smt2 \ cbqi-sdlx-fixpoint-3-dd.smt2 \ qbv-simp.smt2 \ - psyco-001-bv.smt2 + psyco-001-bv.smt2 \ + bug822.smt2 # regression can be solved with --finite-model-find --fmf-inst-engine # set3.smt2 diff --git a/test/regress/regress0/quantifiers/bug822.smt2 b/test/regress/regress0/quantifiers/bug822.smt2 new file mode 100644 index 000000000..fc846b60b --- /dev/null +++ b/test/regress/regress0/quantifiers/bug822.smt2 @@ -0,0 +1,1183 @@ +; COMMAND-LINE: --lang=smt2.6 +; EXPECT: unsat +(set-logic UFDT) +(set-info :source | +Generated by: Andrew Reynolds +Generated on: 2017-04-28 +Generator: Sledgehammer, converted to v2.6 by CVC4 +Application: Verfication goals in Isabelle +Target solver: CVC4, Z3 +Publications: "A Decision Procedure for (Co)Datatypes" by Andrew Reynolds and Jasmin Blanchette, CADE 2015. +|) +(set-info :status unsat) +(declare-sort A$ 0) +(declare-sort B$ 0) +(declare-sort A_a_fun$ 0) +(declare-sort A_b_fun$ 0) +(declare-sort B_a_fun$ 0) +(declare-sort B_b_fun$ 0) +(declare-sort A_bool_fun$ 0) +(declare-sort B_bool_fun$ 0) +(declare-sort A_a_tree_fun$ 0) +(declare-sort A_b_tree_fun$ 0) +(declare-sort A_tree_b_fun$ 0) +(declare-sort B_a_tree_fun$ 0) +(declare-sort B_b_tree_fun$ 0) +(declare-sort B_tree_b_fun$ 0) +(declare-sort A_a_sum_a_fun$ 0) +(declare-sort A_a_sum_b_fun$ 0) +(declare-sort A_b_fun_b_fun$ 0) +(declare-sort B_b_fun_b_fun$ 0) +(declare-sort B_b_sum_b_fun$ 0) +(declare-sort A_a_a_prod_fun$ 0) +(declare-sort A_b_b_prod_fun$ 0) +(declare-sort B_b_b_prod_fun$ 0) +(declare-sort B_b_prod_b_fun$ 0) +(declare-sort B_tree_bool_fun$ 0) +(declare-sort A_b_fun_bool_fun$ 0) +(declare-sort B_b_bool_fun_fun$ 0) +(declare-sort A_tree_a_tree_fun$ 0) +(declare-sort A_tree_b_tree_fun$ 0) +(declare-sort B_tree_a_tree_fun$ 0) +(declare-sort B_tree_b_tree_fun$ 0) +(declare-sort A_b_fun_b_tree_fun$ 0) +(declare-sort B_b_tree_sum_b_fun$ 0) +(declare-sort A_a_fun_a_a_fun_fun$ 0) +(declare-sort A_a_fun_a_b_fun_fun$ 0) +(declare-sort A_a_sum_a_a_sum_fun$ 0) +(declare-sort A_a_sum_b_b_sum_fun$ 0) +(declare-sort A_b_fun_a_a_fun_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun$ 0) +(declare-sort A_b_sum_b_b_sum_fun$ 0) +(declare-sort B_a_fun_b_a_fun_fun$ 0) +(declare-sort B_a_fun_b_b_fun_fun$ 0) +(declare-sort B_b_b_tree_prod_fun$ 0) +(declare-sort B_b_fun_b_a_fun_fun$ 0) +(declare-sort B_b_fun_b_b_fun_fun$ 0) +(declare-sort B_b_sum_b_b_sum_fun$ 0) +(declare-sort A_a_prod_a_a_prod_fun$ 0) +(declare-sort A_a_prod_b_b_prod_fun$ 0) +(declare-sort B_a_b_b_prod_prod_fun$ 0) +(declare-sort B_b_b_b_prod_prod_fun$ 0) +(declare-sort B_b_prod_b_b_prod_fun$ 0) +(declare-sort A_a_sum_tree_a_tree_fun$ 0) +(declare-sort A_a_sum_tree_b_tree_fun$ 0) +(declare-sort B_tree_b_sum_b_tree_fun$ 0) +(declare-sort A_a_fun_a_a_tree_fun_fun$ 0) +(declare-sort A_tree_b_b_prod_tree_fun$ 0) +(declare-sort B_b_fun_b_b_tree_fun_fun$ 0) +(declare-sort B_b_sum_b_tree_b_sum_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_fun$ 0) +(declare-sort B_tree_b_sum_b_b_sum_fun$ 0) +(declare-sort B_tree_b_tree_b_prod_fun$ 0) +(declare-sort A_a_fun_a_a_sum_a_fun_fun$ 0) +(declare-sort A_a_fun_a_b_b_prod_fun_fun$ 0) +(declare-sort A_b_fun_a_b_b_prod_fun_fun$ 0) +(declare-sort B_b_b_prod_fun_b_b_fun_fun$ 0) +(declare-sort B_b_prod_b_tree_b_prod_fun$ 0) +(declare-sort B_tree_b_prod_b_b_prod_fun$ 0) +(declare-sort B_tree_b_tree_bool_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_bool_fun$ 0) +(declare-sort B_tree_tree_b_tree_tree_fun$ 0) +(declare-sort B_b_fun_b_b_bool_fun_fun_fun$ 0) +(declare-sort B_tree_b_tree_fun_b_tree_fun$ 0) +(declare-sort B_tree_b_tree_sum_b_tree_fun$ 0) +(declare-sort A_b_fun_tree_a_b_fun_tree_fun$ 0) +(declare-sort A_b_tree_sum_b_b_tree_sum_fun$ 0) +(declare-sort A_tree_b_sum_a_tree_b_sum_fun$ 0) +(declare-sort A_tree_b_sum_b_tree_b_sum_fun$ 0) +(declare-sort B_a_tree_fun_b_b_tree_fun_fun$ 0) +(declare-sort B_b_fun_tree_b_b_fun_tree_fun$ 0) +(declare-sort B_b_sum_tree_b_b_sum_tree_fun$ 0) +(declare-sort B_b_tree_fun_b_b_tree_fun_fun$ 0) +(declare-sort B_b_tree_sum_b_b_tree_sum_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_fun$ 0) +(declare-sort B_tree_b_fun_b_tree_b_fun_fun$ 0) +(declare-sort B_tree_b_sum_b_tree_b_sum_fun$ 0) +(declare-sort B_tree_b_tree_a_b_fun_sum_fun$ 0) +(declare-sort B_tree_b_tree_b_tree_prod_fun$ 0) +(declare-sort B_tree_b_tree_prod_b_tree_fun$ 0) +(declare-sort A_b_fun_b_tree_a_b_fun_sum_fun$ 0) +(declare-sort B_b_tree_b_tree_prod_prod_b_fun$ 0) +(declare-sort B_b_tree_prod_b_b_tree_prod_fun$ 0) +(declare-sort B_tree_b_prod_b_tree_b_prod_fun$ 0) +(declare-sort A_a_a_prod_fun_a_b_b_prod_fun_fun$ 0) +(declare-sort B_b_b_fun_b_b_bool_fun_fun_fun_fun$ 0) +(declare-sort B_b_tree_sum_b_tree_b_tree_sum_fun$ 0) +(declare-sort B_tree_b_tree_fun_b_tree_b_fun_fun$ 0) +(declare-sort B_tree_b_tree_sum_b_b_tree_sum_fun$ 0) +(declare-sort A_a_a_prod_prod_a_a_a_prod_prod_fun$ 0) +(declare-sort A_a_a_prod_prod_b_b_b_prod_prod_fun$ 0) +(declare-sort A_b_b_prod_prod_a_b_b_prod_prod_fun$ 0) +(declare-sort A_b_b_prod_prod_b_b_b_prod_prod_fun$ 0) +(declare-sort B_b_b_prod_prod_b_b_b_prod_prod_fun$ 0) +(declare-sort A_a_fun_a_a_fun_a_a_tree_fun_fun_fun$ 0) +(declare-sort A_tree_a_a_tree_a_tree_prod_prod_fun$ 0) +(declare-sort A_tree_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort B_b_tree_prod_b_tree_b_tree_prod_fun$ 0) +(declare-sort B_tree_a_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort B_tree_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort B_tree_b_tree_prod_b_b_tree_prod_fun$ 0) +(declare-sort A_b_fun_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort A_tree_a_tree_fun_a_tree_a_tree_fun_fun$ 0) +(declare-sort A_tree_a_tree_fun_a_tree_b_tree_fun_fun$ 0) +(declare-sort A_tree_b_tree_fun_a_tree_a_tree_fun_fun$ 0) +(declare-sort A_tree_b_tree_fun_a_tree_b_tree_fun_fun$ 0) +(declare-sort A_tree_b_tree_sum_a_tree_b_tree_sum_fun$ 0) +(declare-sort A_tree_b_tree_sum_b_tree_b_tree_sum_fun$ 0) +(declare-sort B_tree_a_tree_fun_b_tree_b_tree_fun_fun$ 0) +(declare-sort B_tree_b_tree_fun_b_tree_b_tree_fun_fun$ 0) +(declare-sort B_tree_b_tree_sum_b_tree_b_tree_sum_fun$ 0) +(declare-sort A_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun$ 0) +(declare-sort A_b_fun_b_tree_fun_a_b_fun_b_tree_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_b_tree_prod_fun$ 0) +(declare-sort B_tree_b_tree_prod_b_tree_b_tree_prod_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun$ 0) +(declare-sort B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$ 0) +(declare-sort B_b_b_tree_b_sum_b_tree_b_sum_prod_prod_fun$ 0) +(declare-sort B_tree_b_b_prod_prod_b_tree_b_b_prod_prod_fun$ 0) +(declare-sort B_b_fun_b_b_b_fun_b_b_bool_fun_fun_fun_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$ 0) +(declare-sort B_a_b_b_prod_prod_fun_b_a_b_b_prod_prod_fun_fun$ 0) +(declare-sort A_b_fun_bool_fun_b_tree_a_b_fun_sum_bool_fun_fun$ 0) +(declare-sort B_b_tree_b_tree_prod_prod_b_tree_b_tree_prod_fun$ 0) +(declare-sort B_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun$ 0) +(declare-sort B_tree_b_tree_fun_tree_b_tree_b_tree_fun_tree_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_bool_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun$ 0) +(declare-sort B_tree_b_tree_a_b_fun_sum_fun_b_tree_b_tree_fun_fun$ 0) +(declare-sort B_tree_b_tree_b_tree_prod_fun_b_tree_b_tree_fun_fun$ 0) +(declare-sort A_b_fun_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$ 0) +(declare-sort A_b_fun_b_tree_a_b_fun_sum_fun_a_b_fun_b_tree_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_fun$ 0) +(declare-sort A_a_tree_a_tree_prod_prod_a_a_tree_a_tree_prod_prod_fun$ 0) +(declare-sort A_a_tree_a_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort A_b_tree_b_tree_prod_prod_a_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort A_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort B_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$ 0) +(declare-sort B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort A_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_bool_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_bool_fun$ 0) +(declare-sort B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$ 0) +(declare-sort B_tree_b_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod_fun$ 0) +(declare-sort B_tree_b_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun_fun$ 0) +(declare-sort A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$ 0) +(declare-sort B_tree_b_tree_fun_b_tree_b_tree_prod_b_tree_b_tree_prod_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_b_tree_prod_fun_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_fun$ 0) +(declare-sort A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$ 0) +(declare-sort B_tree_b_tree_b_tree_prod_prod_b_tree_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun$ 0) +(declare-sort A_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_b_tree_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$ 0) +(declare-sort B_tree_a_b_tree_b_tree_prod_prod_fun_b_tree_a_b_tree_b_tree_prod_prod_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun_fun$ 0) +(declare-sort A_a_tree_b_sum_a_tree_b_sum_prod_prod_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$ 0) +(declare-sort A_a_tree_b_sum_a_tree_b_sum_prod_prod_b_b_tree_b_sum_b_tree_b_sum_prod_prod_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$ 0) +(declare-sort B_tree_b_tree_fun_b_tree_b_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun_fun_fun$ 0) +(declare-sort A_a_tree_fun_a_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$ 0) +(declare-sort A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ 0) +(declare-sort B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun_b_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ 0) +(declare-sort A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$ 0) +(declare-sort A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_b_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$ 0) +(declare-sort A_bool_fun_a_a_tree_fun_a_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$ 0) +(declare-sort B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ 0) +(declare-sort A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_fun$ 0) +(declare-sort B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun_b_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun_fun$ 0) +(declare-sort A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun$ 0) +(declare-sort A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$ 0) +(declare-sort A_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun$ 0) +(declare-sort A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun_fun$ 0) +(declare-sort B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$ 0) +(declare-sort A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun_fun$ 0) +(declare-sort A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun_fun_fun$ 0) +(declare-sort B_tree$ 0) +(declare-fun root$ (B_tree$) B$) +(declare-fun left$ (B_tree$) B_tree$) +(declare-fun right$ (B_tree$) B_tree$) +(declare-fun node$ (B$ B_tree$ B_tree$) B_tree$) +(declare-datatypes ((B_tree_b_tree_prod$ 0)(B_b_tree_b_tree_prod_prod$ 0)(B_tree_a_b_fun_sum$ 0)(B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$ 0)(B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$ 0)) (((pair$ (fst$ B_tree$) (snd$ B_tree$))) +((pair$a (fst$a B$) (snd$a B_tree_b_tree_prod$))) +((inl$ (select$ B_tree$)) (inr$ (selecta$ A_b_fun$))) +((pair$b (fst$b B_tree_a_b_fun_sum$) (snd$b B_tree_a_b_fun_sum$))) +((pair$c (fst$c B$) (snd$c B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$))) +)) +(declare-sort A_tree$ 0) +(declare-fun root$a (A_tree$) A$) +(declare-fun left$a (A_tree$) A_tree$) +(declare-fun right$a (A_tree$) A_tree$) +(declare-fun node$a (A$ A_tree$ A_tree$) A_tree$) +(declare-datatypes ((A_tree_a_tree_prod$ 0)(A_a_tree_a_tree_prod_prod$ 0)(B_b_prod$ 0)) (((pair$d (fst$d A_tree$) (snd$d A_tree$))) +((pair$e (fst$e A$) (snd$e A_tree_a_tree_prod$))) +((pair$f (fst$f B$) (snd$f B$))) +)) +(declare-sort B_b_prod_tree$ 0) +(declare-fun root$b (B_b_prod_tree$) B_b_prod$) +(declare-fun left$b (B_b_prod_tree$) B_b_prod_tree$) +(declare-fun right$b (B_b_prod_tree$) B_b_prod_tree$) +(declare-fun node$b (B_b_prod$ B_b_prod_tree$ B_b_prod_tree$) B_b_prod_tree$) +(declare-datatypes ((A_a_sum$ 0)) (((inl$a (projl$ A$)) (inr$a (projr$ A$))) +)) +(declare-sort A_a_sum_tree$ 0) +(declare-sort B_tree_tree$ 0) +(declare-fun root$c (A_a_sum_tree$) A_a_sum$) +(declare-fun left$c (A_a_sum_tree$) A_a_sum_tree$) +(declare-fun right$c (A_a_sum_tree$) A_a_sum_tree$) +(declare-fun node$c (A_a_sum$ A_a_sum_tree$ A_a_sum_tree$) A_a_sum_tree$) +(declare-fun root$d (B_tree_tree$) B_tree$) +(declare-fun left$d (B_tree_tree$) B_tree_tree$) +(declare-fun right$d (B_tree_tree$) B_tree_tree$) +(declare-fun node$d (B_tree$ B_tree_tree$ B_tree_tree$) B_tree_tree$) +(declare-datatypes ((B_b_sum$ 0)) (((inl$b (projl$a B$)) (inr$b (projr$a B$))) +)) +(declare-sort B_b_sum_tree$ 0) +(declare-sort B_tree_b_tree_fun_tree$ 0) +(declare-sort B_b_fun_tree$ 0) +(declare-sort A_b_fun_tree$ 0) +(declare-fun root$e (B_b_sum_tree$) B_b_sum$) +(declare-fun left$e (B_b_sum_tree$) B_b_sum_tree$) +(declare-fun right$e (B_b_sum_tree$) B_b_sum_tree$) +(declare-fun node$e (B_b_sum$ B_b_sum_tree$ B_b_sum_tree$) B_b_sum_tree$) +(declare-fun selectb$ (B_tree_b_tree_fun_tree$) B_tree_b_tree_fun$) +(declare-fun selectc$ (B_tree_b_tree_fun_tree$) B_tree_b_tree_fun_tree$) +(declare-fun selectd$ (B_tree_b_tree_fun_tree$) B_tree_b_tree_fun_tree$) +(declare-fun node$f (B_tree_b_tree_fun$ B_tree_b_tree_fun_tree$ B_tree_b_tree_fun_tree$) B_tree_b_tree_fun_tree$) +(declare-fun selecte$ (B_b_fun_tree$) B_b_fun$) +(declare-fun selectf$ (B_b_fun_tree$) B_b_fun_tree$) +(declare-fun selectg$ (B_b_fun_tree$) B_b_fun_tree$) +(declare-fun node$g (B_b_fun$ B_b_fun_tree$ B_b_fun_tree$) B_b_fun_tree$) +(declare-fun selecth$ (A_b_fun_tree$) A_b_fun$) +(declare-fun selecti$ (A_b_fun_tree$) A_b_fun_tree$) +(declare-fun selectj$ (A_b_fun_tree$) A_b_fun_tree$) +(declare-fun node$h (A_b_fun$ A_b_fun_tree$ A_b_fun_tree$) A_b_fun_tree$) +(declare-datatypes ((A_a_prod$ 0)(A_b_tree_sum$ 0)(A_b_sum$ 0)(B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod$ 0)(B_b_tree_prod$ 0)(B_tree_b_prod$ 0)(B_b_b_prod_prod$ 0)(A_a_a_prod_prod$ 0)(B_tree_b_b_prod_prod$ 0)(B_tree_b_tree_b_tree_prod_prod$ 0)(A_b_b_prod_prod$ 0)(A_b_tree_b_tree_prod_prod$ 0)(A_tree_b_sum$ 0)(A_tree_b_sum_a_tree_b_sum_prod$ 0)(A_a_tree_b_sum_a_tree_b_sum_prod_prod$ 0)(B_tree_b_sum$ 0)(B_tree_b_sum_b_tree_b_sum_prod$ 0)(B_b_tree_b_sum_b_tree_b_sum_prod_prod$ 0)(A_tree_b_tree_sum$ 0)(A_tree_b_tree_sum_a_tree_b_tree_sum_prod$ 0)(A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod$ 0)(B_tree_b_tree_sum$ 0)(B_tree_b_tree_sum_b_tree_b_tree_sum_prod$ 0)(B_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod$ 0)(B_b_tree_sum$ 0)) (((pair$g (fst$g A$) (snd$g A$))) +((inl$c (projl$b A$)) (inr$c (projr$b B_tree$))) +((inl$d (projl$c A$)) (inr$d (projr$c B$))) +((pair$h (fst$h B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (snd$h B$))) +((pair$i (fst$i B$) (snd$i B_tree$))) +((pair$j (fst$j B_tree$) (snd$j B$))) +((pair$k (fst$k B$) (snd$k B_b_prod$))) +((pair$l (fst$l A$) (snd$l A_a_prod$))) +((pair$m (fst$m B_tree$) (snd$m B_b_prod$))) +((pair$n (fst$n B_tree$) (snd$n B_tree_b_tree_prod$))) +((pair$o (fst$o A$) (snd$o B_b_prod$))) +((pair$p (fst$p A$) (snd$p B_tree_b_tree_prod$))) +((inl$e (projl$d A_tree$)) (inr$e (projr$d B$))) +((pair$q (fst$q A_tree_b_sum$) (snd$q A_tree_b_sum$))) +((pair$r (fst$r A$) (snd$r A_tree_b_sum_a_tree_b_sum_prod$))) +((inl$f (projl$e B_tree$)) (inr$f (projr$e B$))) +((pair$s (fst$s B_tree_b_sum$) (snd$s B_tree_b_sum$))) +((pair$t (fst$t B$) (snd$t B_tree_b_sum_b_tree_b_sum_prod$))) +((inl$g (projl$f A_tree$)) (inr$g (projr$f B_tree$))) +((pair$u (fst$u A_tree_b_tree_sum$) (snd$u A_tree_b_tree_sum$))) +((pair$v (fst$v A$) (snd$v A_tree_b_tree_sum_a_tree_b_tree_sum_prod$))) +((inl$h (projl$g B_tree$)) (inr$h (projr$g B_tree$))) +((pair$w (fst$w B_tree_b_tree_sum$) (snd$w B_tree_b_tree_sum$))) +((pair$x (fst$x B$) (snd$x B_tree_b_tree_sum_b_tree_b_tree_sum_prod$))) +((inl$i (projl$h B$)) (inr$i (projr$h B_tree$))) +)) +(declare-fun l$ () A_a_fun$) +(declare-fun r$ () A_a_fun$) +(declare-fun t$ () A_tree$) +(declare-fun x$ () A$) +(declare-fun id$ () B_b_fun$) +(declare-fun uu$ () A_b_fun_b_tree_fun$) +(declare-fun id$a () B_tree_b_tree_fun$) +(declare-fun id$b () B_b_sum_b_b_sum_fun$) +(declare-fun id$c () B_tree_b_tree_fun_b_tree_b_tree_fun_fun$) +(declare-fun id$d () B_b_fun_b_b_fun_fun$) +(declare-fun id$e () A_b_fun_a_b_fun_fun$) +(declare-fun id$f () A_a_fun$) +(declare-fun id$g () B_b_sum_tree_b_b_sum_tree_fun$) +(declare-fun id$h () B_tree_b_tree_fun_tree_b_tree_b_tree_fun_tree_fun$) +(declare-fun id$i () B_b_fun_tree_b_b_fun_tree_fun$) +(declare-fun id$j () A_b_fun_tree_a_b_fun_tree_fun$) +(declare-fun id$k () B_tree_tree_b_tree_tree_fun$) +(declare-fun id$l () A_tree_a_tree_fun$) +(declare-fun id$m () B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun id$n () B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun id$o () B_b_prod_b_b_prod_fun$) +(declare-fun id$p () A_a_prod_a_a_prod_fun$) +(declare-fun id$q () B_b_tree_prod_b_b_tree_prod_fun$) +(declare-fun id$r () B_tree_b_prod_b_tree_b_prod_fun$) +(declare-fun id$s () B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) +(declare-fun id$t () B_b_b_prod_prod_b_b_b_prod_prod_fun$) +(declare-fun id$u () B_tree_b_b_prod_prod_b_tree_b_b_prod_prod_fun$) +(declare-fun id$v () B_tree_b_tree_b_tree_prod_prod_b_tree_b_tree_b_tree_prod_prod_fun$) +(declare-fun id$w () B_b_tree_sum_b_b_tree_sum_fun$) +(declare-fun id$x () B_tree_b_sum_b_tree_b_sum_fun$) +(declare-fun id$y () B_tree_b_tree_sum_b_tree_b_tree_sum_fun$) +(declare-fun id$z (B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum$) +(declare-fun uua$ () B_b_fun$) +(declare-fun uub$ () B_tree_b_tree_fun$) +(declare-fun uuc$ () A_a_fun$) +(declare-fun uud$ (B$) B_b_fun$) +(declare-fun uue$ (B$) A_b_fun$) +(declare-fun uuf$ (B$) B_tree_b_fun$) +(declare-fun uug$ (A$) A_a_fun$) +(declare-fun uuh$ (B_tree$) B_tree_b_tree_fun$) +(declare-fun uui$ (B_tree$) A_b_fun_b_tree_fun$) +(declare-fun uuj$ () B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) +(declare-fun uuk$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun uul$ (B_tree_b_tree_fun$) B_tree_b_tree_fun_b_tree_b_tree_fun_fun$) +(declare-fun uum$ (B_tree_b_tree_fun$) A_b_fun_b_tree_fun_a_b_fun_b_tree_fun_fun$) +(declare-fun uun$ () A_b_fun_b_tree_a_b_fun_sum_fun$) +(declare-fun uuo$ (A$) A_b_fun_b_fun$) +(declare-fun uup$ (A_a_fun$) A_b_fun_a_b_fun_fun$) +(declare-fun uuq$ (A_b_fun_b_fun$) A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun_fun_fun$) +(declare-fun uur$ () B_tree_b_tree_a_b_fun_sum_fun$) +(declare-fun uus$ (B_tree_a_b_fun_sum_b_tree_fun$) B_tree_b_tree_fun$) +(declare-fun uut$ (B_tree_a_b_fun_sum_b_tree_fun$) A_b_fun_b_tree_fun$) +(declare-fun uuu$ (B$) B_b_fun_b_fun$) +(declare-fun uuv$ (B_b_fun$) B_b_fun_b_b_fun_fun$) +(declare-fun uuw$ (B_tree$) B_tree_b_tree_fun_b_tree_fun$) +(declare-fun uux$ (B_tree_b_tree_fun$) B_tree_b_tree_fun_b_tree_b_tree_fun_fun$) +(declare-fun uuy$ (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun_fun$) +(declare-fun uuz$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_bool_fun_fun$) +(declare-fun uva$ () B_b_tree_b_tree_prod_prod_b_fun$) +(declare-fun uvb$ () B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$) +(declare-fun uvc$ () B_tree_b_tree_prod_b_tree_fun$) +(declare-fun uvd$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) +(declare-fun uve$ () B_b_tree_b_tree_prod_prod_b_tree_b_tree_prod_fun$) +(declare-fun uvf$ () B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun uvg$ () B_tree_b_tree_prod_b_tree_fun$) +(declare-fun uvh$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) +(declare-fun uvi$ () B_b_prod_b_fun$) +(declare-fun uvj$ () B_b_b_prod_fun$) +(declare-fun uvk$ () B_tree_b_tree_b_tree_prod_fun$) +(declare-fun uvl$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun uvm$ () B_b_prod_b_fun$) +(declare-fun uvn$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$) +(declare-fun uvo$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$) +(declare-fun uvp$ () B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$) +(declare-fun uvq$ () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$) +(declare-fun uvr$ (B_b_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun_fun$) +(declare-fun uvs$ (B_tree_a_b_fun_sum_b_tree_fun$ B_tree_a_b_fun_sum_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_b_tree_prod_fun_fun$) +(declare-fun comp$ (B_tree_b_tree_fun$) B_tree_b_tree_fun_b_tree_b_tree_fun_fun$) +(declare-fun id$aa () B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun swap$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun xtor$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun apfst$ (B_b_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun apsnd$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun comp$a (B_b_fun$) B_b_fun_b_b_fun_fun$) +(declare-fun comp$b (A_b_fun$) A_a_fun_a_b_fun_fun$) +(declare-fun comp$c (B_b_fun$) A_b_fun_a_b_fun_fun$) +(declare-fun comp$d (B_a_fun$) A_b_fun_a_a_fun_fun$) +(declare-fun comp$e (A_a_fun$) A_a_fun_a_a_fun_fun$) +(declare-fun comp$f (A_b_fun$) B_a_fun_b_b_fun_fun$) +(declare-fun comp$g (A_a_fun$) B_a_fun_b_a_fun_fun$) +(declare-fun comp$h (B_a_fun$) B_b_fun_b_a_fun_fun$) +(declare-fun comp$i (A_b_b_prod_fun$) A_a_fun_a_b_b_prod_fun_fun$) +(declare-fun comp$j (A_b_fun$ A_a_sum_a_fun$) A_a_sum_b_fun$) +(declare-fun comp$k (B_tree_b_tree_fun$) A_tree_b_tree_fun_a_tree_b_tree_fun_fun$) +(declare-fun comp$l (A_tree_b_tree_fun$) A_tree_a_tree_fun_a_tree_b_tree_fun_fun$) +(declare-fun comp$m (B_tree_a_tree_fun$) A_tree_b_tree_fun_a_tree_a_tree_fun_fun$) +(declare-fun comp$n (A_tree_a_tree_fun$) A_tree_a_tree_fun_a_tree_a_tree_fun_fun$) +(declare-fun comp$o (A_tree_a_tree_fun$ B_tree_a_tree_fun$) B_tree_a_tree_fun$) +(declare-fun comp$p (B_tree_a_tree_fun$ B_tree_b_tree_fun$) B_tree_a_tree_fun$) +(declare-fun comp$q (A_tree_b_tree_fun$) B_tree_a_tree_fun_b_tree_b_tree_fun_fun$) +(declare-fun comp$r (A_tree_b_b_prod_tree_fun$ A_tree_a_tree_fun$) A_tree_b_b_prod_tree_fun$) +(declare-fun comp$s (A_tree_b_tree_fun$ A_a_sum_tree_a_tree_fun$) A_a_sum_tree_b_tree_fun$) +(declare-fun comp$t (A_a_prod_b_b_prod_fun$ A_a_prod_a_a_prod_fun$) A_a_prod_b_b_prod_fun$) +(declare-fun comp$u (B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$v (B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$) +(declare-fun comp$w (B_tree_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$) +(declare-fun comp$x (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$y (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$) +(declare-fun comp$z (B_tree_a_b_fun_sum_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$) +(declare-fun swap$a (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod$) +(declare-fun swap$b (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun xtor$a (B_b_tree_b_tree_prod_prod$) B_b_tree_b_tree_prod_prod$) +(declare-fun xtor$b (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun xtor$c (B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum$) +(declare-fun apfst$a (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun apsnd$a (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun apsnd$b (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$aa (B_tree_a_b_fun_sum_b_tree_fun$) A_b_fun_b_tree_a_b_fun_sum_fun_a_b_fun_b_tree_fun_fun$) +(declare-fun comp$ab (B_tree_b_tree_fun$) A_b_fun_b_tree_fun_a_b_fun_b_tree_fun_fun$) +(declare-fun comp$ac (A_tree_b_tree_fun$ A_a_tree_fun$) A_b_tree_fun$) +(declare-fun comp$ad (B_tree_a_b_fun_sum_b_tree_fun$) B_tree_b_tree_a_b_fun_sum_fun_b_tree_b_tree_fun_fun$) +(declare-fun comp$ae (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$ A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) A_b_fun_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$af (B_tree_b_b_tree_b_tree_prod_prod_fun$ A_b_fun_b_tree_fun$) A_b_fun_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$ag (A_a_a_prod_prod_b_b_b_prod_prod_fun$ A_a_a_prod_prod_a_a_a_prod_prod_fun$) A_a_a_prod_prod_b_b_b_prod_prod_fun$) +(declare-fun comp$ah (A_tree_b_tree_fun$) B_a_tree_fun_b_b_tree_fun_fun$) +(declare-fun comp$ai (A_b_b_prod_prod_b_b_b_prod_prod_fun$ B_a_b_b_prod_prod_fun$) B_b_b_b_prod_prod_fun$) +(declare-fun comp$aj (A_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ B_tree_a_b_tree_b_tree_prod_prod_fun$) B_tree_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$ak (A_tree_a_tree_fun$ B_a_tree_fun$) B_a_tree_fun$) +(declare-fun comp$al (A_b_b_prod_prod_a_b_b_prod_prod_fun$) B_a_b_b_prod_prod_fun_b_a_b_b_prod_prod_fun_fun$) +(declare-fun comp$am (A_b_tree_b_tree_prod_prod_a_b_tree_b_tree_prod_prod_fun$) B_tree_a_b_tree_b_tree_prod_prod_fun_b_tree_a_b_tree_b_tree_prod_prod_fun_fun$) +(declare-fun comp$an (B_b_prod_b_b_prod_fun$ B_b_b_prod_fun$ B$) B_b_prod$) +(declare-fun comp$ao (B_b_prod_b_tree_b_prod_fun$ B_b_b_prod_fun$ B$) B_tree_b_prod$) +(declare-fun comp$ap (B_tree_b_tree_fun$) B_b_tree_fun_b_b_tree_fun_fun$) +(declare-fun comp$aq (B_tree_b_prod_b_b_prod_fun$ B_tree_b_tree_b_prod_fun$ B_tree$) B_b_prod$) +(declare-fun comp$ar (B_b_fun$) B_tree_b_fun_b_tree_b_fun_fun$) +(declare-fun comp$as (B_tree_b_prod_b_tree_b_prod_fun$ B_tree_b_tree_b_prod_fun$ B_tree$) B_tree_b_prod$) +(declare-fun comp$at (B_b_tree_prod_b_b_tree_prod_fun$ B_b_b_tree_prod_fun$ B$) B_b_tree_prod$) +(declare-fun comp$au (B_b_tree_prod_b_tree_b_tree_prod_fun$ B_b_b_tree_prod_fun$ B$) B_tree_b_tree_prod$) +(declare-fun comp$av (B_tree_b_tree_prod_b_b_tree_prod_fun$ B_tree_b_tree_b_tree_prod_fun$ B_tree$) B_b_tree_prod$) +(declare-fun comp$aw (B_tree_b_tree_prod_b_tree_b_tree_prod_fun$ B_tree_b_tree_b_tree_prod_fun$ B_tree$) B_tree_b_tree_prod$) +(declare-fun comp$ax (A_tree_a_a_tree_a_tree_prod_prod_fun$ A_tree_a_tree_fun$) A_tree_a_a_tree_a_tree_prod_prod_fun$) +(declare-fun comp$ay (A_a_tree_a_tree_prod_prod_a_a_tree_a_tree_prod_prod_fun$ A_tree_a_a_tree_a_tree_prod_prod_fun$) A_tree_a_a_tree_a_tree_prod_prod_fun$) +(declare-fun comp$az (B_tree_b_b_tree_b_tree_prod_prod_fun$ A_tree_b_tree_fun$) A_tree_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$ba (A_a_tree_a_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ A_tree_a_a_tree_a_tree_prod_prod_fun$) A_tree_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$bb (B_tree_b_b_tree_b_tree_prod_prod_fun$ B_tree_b_tree_fun$) B_tree_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$bc (B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ B_tree_b_b_tree_b_tree_prod_prod_fun$) B_tree_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun comp$bd (A_a_prod_b_b_prod_fun$) A_a_a_prod_fun_a_b_b_prod_fun_fun$) +(declare-fun comp$be (A_a_tree_b_sum_a_tree_b_sum_prod_prod_b_b_tree_b_sum_b_tree_b_sum_prod_prod_fun$ B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$) B_b_b_tree_b_sum_b_tree_b_sum_prod_prod_fun$) +(declare-fun comp$bf (A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_b_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod_fun$ B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$) B_tree_b_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod_fun$) +(declare-fun comp$bg (A_a_tree_b_sum_a_tree_b_sum_prod_prod_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$) B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun_b_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun_fun$) +(declare-fun comp$bh (A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$) B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun_b_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun_fun$) +(declare-fun comp$bi (A_a_sum_b_b_sum_fun$ A_a_sum_a_a_sum_fun$) A_a_sum_b_b_sum_fun$) +(declare-fun comp$bj (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$ A_b_fun_b_tree_a_b_fun_sum_fun$) A_b_fun_b_tree_a_b_fun_sum_fun$) +(declare-fun comp$bk (A_b_fun_b_tree_a_b_fun_sum_fun$ A_b_fun_a_b_fun_fun$) A_b_fun_b_tree_a_b_fun_sum_fun$) +(declare-fun comp$bl (A_a_sum_b_fun$ A_a_sum_a_a_sum_fun$) A_a_sum_b_fun$) +(declare-fun comp$bm (A_b_fun_b_tree_fun$) A_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun$) +(declare-fun comp$bn (B_b_sum_b_fun$ B_b_sum_b_b_sum_fun$ B_b_sum$) B$) +(declare-fun comp$bo (B_b_sum_b_fun$ A_b_sum_b_b_sum_fun$ A_b_sum$) B$) +(declare-fun comp$bp (B_b_sum_b_fun$ B_tree_b_sum_b_b_sum_fun$ B_tree_b_sum$) B$) +(declare-fun comp$bq (B_tree_b_fun$) B_tree_b_tree_fun_b_tree_b_fun_fun$) +(declare-fun comp$br (B_b_tree_sum_b_fun$ B_b_tree_sum_b_b_tree_sum_fun$ B_b_tree_sum$) B$) +(declare-fun comp$bs (B_tree_b_sum_b_tree_fun$ B_b_sum_b_tree_b_sum_fun$ B_b_sum$) B_tree$) +(declare-fun comp$bt (B_b_tree_fun$) B_b_fun_b_b_tree_fun_fun$) +(declare-fun comp$bu (B_b_tree_sum_b_fun$ A_b_tree_sum_b_b_tree_sum_fun$ A_b_tree_sum$) B$) +(declare-fun comp$bv (B_b_tree_sum_b_fun$ B_tree_b_tree_sum_b_b_tree_sum_fun$ B_tree_b_tree_sum$) B$) +(declare-fun comp$bw (B_tree_b_sum_b_tree_fun$ B_tree_b_sum_b_tree_b_sum_fun$ B_tree_b_sum$) B_tree$) +(declare-fun comp$bx (B_tree_b_tree_sum_b_tree_fun$ B_b_tree_sum_b_tree_b_tree_sum_fun$ B_b_tree_sum$) B_tree$) +(declare-fun comp$by (B_tree_b_tree_sum_b_tree_fun$ B_tree_b_tree_sum_b_tree_b_tree_sum_fun$ B_tree_b_tree_sum$) B_tree$) +(declare-fun comp$bz (B_b_tree_b_tree_prod_prod_b_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$) +(declare-fun comp$ca (B_b_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$) +(declare-fun comp$cb (B_tree_b_tree_prod_b_tree_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_fun$) +(declare-fun comp$cc (B_tree_a_b_fun_sum_b_tree_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_fun$) +(declare-fun comp$cd (B_b_tree_b_tree_prod_prod_b_tree_b_tree_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_b_tree_prod_fun$) +(declare-fun comp$ce (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_b_tree_prod_fun$) +(declare-fun comp$cf (B_b_prod_b_fun$) B_b_b_prod_fun_b_b_fun_fun$) +(declare-fun comp$cg (B_tree_b_tree_prod_b_tree_fun$) B_tree_b_tree_b_tree_prod_fun_b_tree_b_tree_fun_fun$) +(declare-fun comp$ch (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_fun$) +(declare-fun comp$ci (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod$) B$) +(declare-fun comp$cj (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun_fun$) +(declare-fun convol$ (B_b_fun$ B_b_fun$) B_b_b_prod_fun$) +(declare-fun id_bnf$ (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun member$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) Bool) +(declare-fun convol$a (B_b_tree_fun$ B_b_fun$ B$) B_tree_b_prod$) +(declare-fun convol$b (B_tree_b_tree_fun$ B_tree_b_fun$) B_tree_b_tree_b_prod_fun$) +(declare-fun convol$c (B_tree_b_fun$ B_tree_b_fun$ B_tree$) B_b_prod$) +(declare-fun convol$d (B_b_fun$ B_b_tree_fun$) B_b_b_tree_prod_fun$) +(declare-fun convol$e (B_b_tree_fun$ B_b_tree_fun$ B$) B_tree_b_tree_prod$) +(declare-fun convol$f (B_tree_b_tree_fun$ B_tree_b_tree_fun$) B_tree_b_tree_b_tree_prod_fun$) +(declare-fun convol$g (B_tree_b_fun$ B_tree_b_tree_fun$ B_tree$) B_b_tree_prod$) +(declare-fun convol$h (A_b_fun$) A_b_fun_a_b_b_prod_fun_fun$) +(declare-fun convol$i (A_a_fun$ A_a_fun$) A_a_a_prod_fun$) +(declare-fun fun_app$ (B_tree_b_tree_b_tree_prod_fun$ B_tree$) B_tree_b_tree_prod$) +(declare-fun id_bnf$a (B_b_tree_b_tree_prod_prod$) B_b_tree_b_tree_prod_prod$) +(declare-fun id_bnf$b (A_a_tree_a_tree_prod_prod$) A_a_tree_a_tree_prod_prod$) +(declare-fun id_bnf$c () A_a_fun$) +(declare-fun id_bnf$d (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun id_bnf$e (B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum$) +(declare-fun map_sum$ (A_tree_b_tree_fun$ B_b_fun$) A_tree_b_sum_b_tree_b_sum_fun$) +(declare-fun member$a (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) Bool) +(declare-fun uncurry$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun case_sum$ (B_tree_b_tree_fun$) A_b_fun_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$) +(declare-fun ctor_rec$ (A_b_fun$) A_b_fun$) +(declare-fun fun_app$a (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun fun_app$b (B_b_b_prod_fun$ B$) B_b_prod$) +(declare-fun fun_app$c (A_b_fun_b_tree_fun$ A_b_fun$) B_tree$) +(declare-fun fun_app$d (A_tree_b_tree_fun$ A_tree$) B_tree$) +(declare-fun fun_app$e (B_tree_b_tree_prod_b_tree_fun$ B_tree_b_tree_prod$) B_tree$) +(declare-fun fun_app$f (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_a_b_fun_sum$) +(declare-fun fun_app$g (B_b_tree_b_tree_prod_prod_b_tree_b_tree_prod_fun$ B_b_tree_b_tree_prod_prod$) B_tree_b_tree_prod$) +(declare-fun fun_app$h (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun fun_app$i (B_b_prod_b_fun$ B_b_prod$) B$) +(declare-fun fun_app$j (B_b_tree_b_tree_prod_prod_b_fun$ B_b_tree_b_tree_prod_prod$) B$) +(declare-fun fun_app$k (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B$) +(declare-fun fun_app$l (A_b_fun_b_tree_a_b_fun_sum_fun$ A_b_fun$) B_tree_a_b_fun_sum$) +(declare-fun fun_app$m (B_tree_b_tree_a_b_fun_sum_fun$ B_tree$) B_tree_a_b_fun_sum$) +(declare-fun fun_app$n (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$ B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun fun_app$o (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun fun_app$p (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$ B$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun fun_app$q (B_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ B$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun fun_app$r (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun fun_app$s (B_tree_b_tree_fun_b_tree_b_tree_fun_fun$ B_tree_b_tree_fun$) B_tree_b_tree_fun$) +(declare-fun fun_app$t (B_b_fun_b_b_fun_fun$ B_b_fun$) B_b_fun$) +(declare-fun fun_app$u (A_b_fun_a_b_fun_fun$ A_b_fun$) A_b_fun$) +(declare-fun fun_app$v (A_a_fun_a_b_fun_fun$ A_a_fun$) A_b_fun$) +(declare-fun fun_app$w (B_tree_a_b_fun_sum_b_tree_fun$ B_tree_a_b_fun_sum$) B_tree$) +(declare-fun fun_app$x (B_tree_b_tree_fun$ B_tree$) B_tree$) +(declare-fun fun_app$y (B_tree_b_tree_fun_b_tree_fun$ B_tree_b_tree_fun$) B_tree$) +(declare-fun fun_app$z (B_b_fun_b_fun$ B_b_fun$) B$) +(declare-fun map_prod$ (B_b_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_sum$a (A_tree_b_tree_fun$ B_tree_b_tree_fun$) A_tree_b_tree_sum_b_tree_b_tree_sum_fun$) +(declare-fun map_sum$b (A_tree_a_tree_fun$ B_b_fun$) A_tree_b_sum_a_tree_b_sum_fun$) +(declare-fun map_sum$c (A_tree_a_tree_fun$ B_tree_b_tree_fun$) A_tree_b_tree_sum_a_tree_b_tree_sum_fun$) +(declare-fun map_sum$d (A_b_fun$ A_b_fun$) A_a_sum_b_b_sum_fun$) +(declare-fun map_sum$e (A_a_fun$ A_a_fun$) A_a_sum_a_a_sum_fun$) +(declare-fun map_sum$f (B_b_fun$ B_b_fun$) B_b_sum_b_b_sum_fun$) +(declare-fun map_sum$g (B_b_fun$ B_tree_b_tree_fun$) B_b_tree_sum_b_b_tree_sum_fun$) +(declare-fun map_sum$h (B_tree_b_tree_fun$ B_b_fun$) B_tree_b_sum_b_tree_b_sum_fun$) +(declare-fun map_sum$i (B_tree_b_tree_fun$ B_tree_b_tree_fun$) B_tree_b_tree_sum_b_tree_b_tree_sum_fun$) +(declare-fun map_sum$j (B_tree_b_tree_fun$) A_b_fun_a_b_fun_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_fun$) +(declare-fun map_sum$k (A_b_fun$ B_b_fun$) A_b_sum_b_b_sum_fun$) +(declare-fun map_sum$l (B_tree_b_fun$ B_b_fun$) B_tree_b_sum_b_b_sum_fun$) +(declare-fun map_sum$m (B_b_tree_fun$ B_b_fun$) B_b_sum_b_tree_b_sum_fun$) +(declare-fun map_sum$n (A_b_fun$ B_tree_b_tree_fun$) A_b_tree_sum_b_b_tree_sum_fun$) +(declare-fun map_sum$o (B_tree_b_fun$ B_tree_b_tree_fun$) B_tree_b_tree_sum_b_b_tree_sum_fun$) +(declare-fun map_sum$p (B_b_tree_fun$ B_tree_b_tree_fun$) B_b_tree_sum_b_tree_b_tree_sum_fun$) +(declare-fun map_tree$ (A_b_fun$) A_tree_b_tree_fun$) +(declare-fun uncurry$a (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun uncurry$b (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun uncurry$c (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun uncurry$d (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_b_tree_prod_fun_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) +(declare-fun case_sum$a (B_b_fun$ B_b_fun$) B_b_sum_b_fun$) +(declare-fun case_sum$b (A_b_fun$ B_tree_b_fun$ A_b_tree_sum$) B$) +(declare-fun case_sum$c (A_b_fun$ B_b_fun$ A_b_sum$) B$) +(declare-fun case_sum$d (A_b_fun$ A_b_fun$) A_a_sum_b_fun$) +(declare-fun case_sum$e (A_a_fun$) A_a_fun_a_a_sum_a_fun_fun$) +(declare-fun case_sum$f (B_tree_bool_fun$) A_b_fun_bool_fun_b_tree_a_b_fun_sum_bool_fun_fun$) +(declare-fun case_sum$g (B_tree_b_fun$ B_b_fun$ B_tree_b_sum$) B$) +(declare-fun case_sum$h (B_b_fun$ B_tree_b_fun$) B_b_tree_sum_b_fun$) +(declare-fun case_sum$i (B_tree_b_tree_fun$ B_b_tree_fun$) B_tree_b_sum_b_tree_fun$) +(declare-fun case_sum$j (B_b_tree_fun$ B_b_tree_fun$ B_b_sum$) B_tree$) +(declare-fun case_sum$k (B_tree_b_fun$ B_tree_b_fun$ B_tree_b_tree_sum$) B$) +(declare-fun case_sum$l (B_tree_b_tree_fun$ B_tree_b_tree_fun$) B_tree_b_tree_sum_b_tree_fun$) +(declare-fun case_sum$m (B_b_tree_fun$ B_tree_b_tree_fun$ B_b_tree_sum$) B_tree$) +(declare-fun ctor_tree$ (B_b_tree_b_tree_prod_prod$) B_tree$) +(declare-fun dtor_tree$ () B_tree_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun fun_app$aa (B_b_fun$ B$) B$) +(declare-fun fun_app$ab (A_b_fun_b_fun$ A_b_fun$) B$) +(declare-fun fun_app$ac (A_b_fun$ A$) B$) +(declare-fun fun_app$ad (B_tree_a_b_fun_sum_bool_fun$ B_tree_a_b_fun_sum$) Bool) +(declare-fun fun_app$ae (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_bool_fun_fun$ B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum_bool_fun$) +(declare-fun fun_app$af (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) Bool) +(declare-fun fun_app$ag (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun_fun$ B$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun$) +(declare-fun fun_app$ah (A_b_fun_b_tree_fun_a_b_fun_b_tree_fun_fun$ A_b_fun_b_tree_fun$) A_b_fun_b_tree_fun$) +(declare-fun fun_app$ai (B_tree_a_b_fun_sum_b_tree_b_tree_prod_fun$ B_tree_a_b_fun_sum$) B_tree_b_tree_prod$) +(declare-fun fun_app$aj (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_b_tree_prod_fun_fun$ B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum_b_tree_b_tree_prod_fun$) +(declare-fun fun_app$ak (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_b_tree_b_tree_prod_prod$) +(declare-fun fun_app$al (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun_fun$ B$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun fun_app$am (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_b_tree_prod$) +(declare-fun fun_app$an (A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ A_b_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun fun_app$ao (A_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$ A_b_fun_a_b_fun_fun$) A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun fun_app$ap (A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun$ A_b_fun_b_tree_fun$) A_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$) +(declare-fun fun_app$aq (A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun$ A_b_fun_bool_fun$) A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun$) +(declare-fun fun_app$ar (A_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun$ A_b_fun_a_b_fun_fun$) A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun$) +(declare-fun fun_app$as (A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun_fun$ A_b_fun_b_tree_fun$) A_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun$) +(declare-fun fun_app$at (A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun_fun_fun$ A_b_fun_bool_fun$) A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun_fun_fun_fun_fun$) +(declare-fun fun_app$au (A_b_fun_bool_fun$ A_b_fun$) Bool) +(declare-fun fun_app$av (B_tree_b_fun$ B_tree$) B$) +(declare-fun fun_app$aw (A_a_fun$ A$) A$) +(declare-fun fun_app$ax (B_tree_b_tree_prod_b_tree_b_tree_prod_fun$ B_tree_b_tree_prod$) B_tree_b_tree_prod$) +(declare-fun fun_app$ay (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun fun_app$az (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_b_tree_prod_prod$) +(declare-fun fun_app$ba (B_tree_a_b_fun_sum_b_tree_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$ B_tree_a_b_fun_sum_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) +(declare-fun fun_app$bb (A_b_fun_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$ A_b_fun_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_fun$) +(declare-fun fun_app$bc (B_tree_b_b_tree_b_tree_prod_prod_fun$ B_tree$) B_b_tree_b_tree_prod_prod$) +(declare-fun fun_app$bd (A_tree_a_a_tree_a_tree_prod_prod_fun$ A_tree$) A_a_tree_a_tree_prod_prod$) +(declare-fun fun_app$be (B_tree_a_tree_fun$ B_tree$) A_tree$) +(declare-fun fun_app$bf (A_tree_a_tree_fun$ A_tree$) A_tree$) +(declare-fun fun_app$bg (A_b_fun_a_a_fun_fun$ A_b_fun$) A_a_fun$) +(declare-fun fun_app$bh (A_a_fun_a_a_fun_fun$ A_a_fun$) A_a_fun$) +(declare-fun fun_app$bi (B_a_fun_b_b_fun_fun$ B_a_fun$) B_b_fun$) +(declare-fun fun_app$bj (B_a_fun_b_a_fun_fun$ B_a_fun$) B_a_fun$) +(declare-fun fun_app$bk (B_b_fun_b_a_fun_fun$ B_b_fun$) B_a_fun$) +(declare-fun fun_app$bl (A_tree_b_b_prod_tree_fun$ A_tree$) B_b_prod_tree$) +(declare-fun fun_app$bm (A_a_fun_a_b_b_prod_fun_fun$ A_a_fun$) A_b_b_prod_fun$) +(declare-fun fun_app$bn (A_a_sum_tree_a_tree_fun$ A_a_sum_tree$) A_tree$) +(declare-fun fun_app$bo (A_a_sum_tree_b_tree_fun$ A_a_sum_tree$) B_tree$) +(declare-fun fun_app$bp (A_tree_b_tree_fun_a_tree_b_tree_fun_fun$ A_tree_b_tree_fun$) A_tree_b_tree_fun$) +(declare-fun fun_app$bq (A_tree_a_tree_fun_a_tree_b_tree_fun_fun$ A_tree_a_tree_fun$) A_tree_b_tree_fun$) +(declare-fun fun_app$br (A_tree_b_tree_fun_a_tree_a_tree_fun_fun$ A_tree_b_tree_fun$) A_tree_a_tree_fun$) +(declare-fun fun_app$bs (A_tree_a_tree_fun_a_tree_a_tree_fun_fun$ A_tree_a_tree_fun$) A_tree_a_tree_fun$) +(declare-fun fun_app$bt (B_tree_a_tree_fun_b_tree_b_tree_fun_fun$ B_tree_a_tree_fun$) B_tree_b_tree_fun$) +(declare-fun fun_app$bu (B_tree_tree_b_tree_tree_fun$ B_tree_tree$) B_tree_tree$) +(declare-fun fun_app$bv (B_b_sum_tree_b_b_sum_tree_fun$ B_b_sum_tree$) B_b_sum_tree$) +(declare-fun fun_app$bw (B_tree_b_tree_fun_tree_b_tree_b_tree_fun_tree_fun$ B_tree_b_tree_fun_tree$) B_tree_b_tree_fun_tree$) +(declare-fun fun_app$bx (B_b_fun_tree_b_b_fun_tree_fun$ B_b_fun_tree$) B_b_fun_tree$) +(declare-fun fun_app$by (A_b_fun_tree_a_b_fun_tree_fun$ A_b_fun_tree$) A_b_fun_tree$) +(declare-fun fun_app$bz (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) +(declare-fun fun_app$ca (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$ B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum$) +(declare-fun fun_app$cb (B_b_tree_a_b_fun_sum_fun$ B$) B_tree_a_b_fun_sum$) +(declare-fun fun_app$cc (B_tree_a_b_fun_sum_b_fun$ B_tree_a_b_fun_sum$) B$) +(declare-fun fun_app$cd (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun fun_app$ce (B_b_prod_b_b_prod_fun$ B_b_prod$) B_b_prod$) +(declare-fun fun_app$cf (A_a_prod_b_b_prod_fun$ A_a_prod$) B_b_prod$) +(declare-fun fun_app$cg (A_a_prod_a_a_prod_fun$ A_a_prod$) A_a_prod$) +(declare-fun fun_app$ch (A_tree_b_fun$ A_tree$) B$) +(declare-fun fun_app$ci (B_b_sum_b_fun$ B_b_sum$) B$) +(declare-fun fun_app$cj (A_a_sum_b_fun$ A_a_sum$) B$) +(declare-fun fun_app$ck (A_a_sum_a_fun$ A_a_sum$) A$) +(declare-fun fun_app$cl (A_a_fun_a_a_sum_a_fun_fun$ A_a_fun$) A_a_sum_a_fun$) +(declare-fun fun_app$cm (B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ B_b_tree_b_tree_prod_prod$) B_b_tree_b_tree_prod_prod$) +(declare-fun fun_app$cn (B_b_sum_b_b_sum_fun$ B_b_sum$) B_b_sum$) +(declare-fun fun_app$co (B_a_fun$ B$) A$) +(declare-fun fun_app$cp (A_b_b_prod_fun$ A$) B_b_prod$) +(declare-fun fun_app$cq (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_bool_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) Bool) +(declare-fun fun_app$cr (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) +(declare-fun fun_app$cs (B_tree_b_tree_fun_b_tree_b_tree_prod_b_tree_b_tree_prod_fun_fun$ B_tree_b_tree_fun$) B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) +(declare-fun fun_app$ct (B_tree_a_b_fun_sum_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$ B_tree_a_b_fun_sum_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_fun$) +(declare-fun fun_app$cu (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) +(declare-fun fun_app$cv (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_fun$) +(declare-fun fun_app$cw (B_b_tree_prod_b_b_tree_prod_fun$ B_b_tree_prod$) B_b_tree_prod$) +(declare-fun fun_app$cx (B_tree_b_prod_b_tree_b_prod_fun$ B_tree_b_prod$) B_tree_b_prod$) +(declare-fun fun_app$cy (A_b_fun_b_tree_a_b_fun_sum_fun_a_b_fun_b_tree_fun_fun$ A_b_fun_b_tree_a_b_fun_sum_fun$) A_b_fun_b_tree_fun$) +(declare-fun fun_app$cz (A_a_fun_a_a_tree_fun_fun$ A_a_fun$) A_a_tree_fun$) +(declare-fun fun_app$da (A_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun$ A_a_tree_fun$) A_a_fun_a_a_tree_fun_fun$) +(declare-fun fun_app$db (A_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun$ A_bool_fun$) A_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun$) +(declare-fun fun_app$dc (A_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun$ A_a_fun$) A_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun$) +(declare-fun fun_app$dd (A_a_tree_fun_a_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun_fun$ A_a_tree_fun$) A_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun$) +(declare-fun fun_app$de (A_bool_fun_a_a_tree_fun_a_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun_fun_fun$ A_bool_fun$) A_a_tree_fun_a_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun_fun$) +(declare-fun fun_app$df (A_b_fun_bool_fun_b_tree_a_b_fun_sum_bool_fun_fun$ A_b_fun_bool_fun$) B_tree_a_b_fun_sum_bool_fun$) +(declare-fun fun_app$dg (B_tree_bool_fun$ B_tree$) Bool) +(declare-fun fun_app$dh (A_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun$ A_b_fun_a_b_fun_fun$) A_b_fun_b_tree_fun$) +(declare-fun fun_app$di (A_b_fun_a_b_fun_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun$ A_b_fun_a_b_fun_fun$) A_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun$) +(declare-fun fun_app$dj (A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun$ A_b_fun_b_tree_fun$) A_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun$) +(declare-fun fun_app$dk (A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun$ A_b_fun_bool_fun$) A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun$) +(declare-fun fun_app$dl (A_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun$ A_b_fun_a_b_fun_fun$) A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun$) +(declare-fun fun_app$dm (A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun_fun$ A_b_fun_b_tree_fun$) A_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun$) +(declare-fun fun_app$dn (A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun_fun_fun$ A_b_fun_bool_fun$) A_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun_fun$) +(declare-fun fun_app$do (B_tree_b_tree_a_b_fun_sum_fun_b_tree_b_tree_fun_fun$ B_tree_b_tree_a_b_fun_sum_fun$) B_tree_b_tree_fun$) +(declare-fun fun_app$dp (A_a_tree_fun$ A$) A_tree$) +(declare-fun fun_app$dq (A_a_fun_a_a_fun_a_a_tree_fun_fun_fun$ A_a_fun$) A_a_fun_a_a_tree_fun_fun$) +(declare-fun fun_app$dr (A_a_a_prod_prod_b_b_b_prod_prod_fun$ A_a_a_prod_prod$) B_b_b_prod_prod$) +(declare-fun fun_app$ds (A_a_a_prod_prod_a_a_a_prod_prod_fun$ A_a_a_prod_prod$) A_a_a_prod_prod$) +(declare-fun fun_app$dt (B_b_b_prod_prod_b_b_b_prod_prod_fun$ B_b_b_prod_prod$) B_b_b_prod_prod$) +(declare-fun fun_app$du (B_tree_b_b_prod_prod_b_tree_b_b_prod_prod_fun$ B_tree_b_b_prod_prod$) B_tree_b_b_prod_prod$) +(declare-fun fun_app$dv (B_tree_b_tree_b_tree_prod_prod_b_tree_b_tree_b_tree_prod_prod_fun$ B_tree_b_tree_b_tree_prod_prod$) B_tree_b_tree_b_tree_prod_prod$) +(declare-fun fun_app$dw (B_a_tree_fun_b_b_tree_fun_fun$ B_a_tree_fun$) B_b_tree_fun$) +(declare-fun fun_app$dx (B_a_b_b_prod_prod_fun_b_a_b_b_prod_prod_fun_fun$ B_a_b_b_prod_prod_fun$) B_a_b_b_prod_prod_fun$) +(declare-fun fun_app$dy (B_tree_a_b_tree_b_tree_prod_prod_fun_b_tree_a_b_tree_b_tree_prod_prod_fun_fun$ B_tree_a_b_tree_b_tree_prod_prod_fun$) B_tree_a_b_tree_b_tree_prod_prod_fun$) +(declare-fun fun_app$dz (B_b_tree_fun$ B$) B_tree$) +(declare-fun fun_app$ea (B_b_fun_b_b_tree_fun_fun$ B_b_fun$) B_b_tree_fun$) +(declare-fun fun_app$eb (B_b_tree_fun_b_b_tree_fun_fun$ B_b_tree_fun$) B_b_tree_fun$) +(declare-fun fun_app$ec (B_tree_b_fun_b_tree_b_fun_fun$ B_tree_b_fun$) B_tree_b_fun$) +(declare-fun fun_app$ed (B_tree_b_tree_b_prod_fun$ B_tree$) B_tree_b_prod$) +(declare-fun fun_app$ee (B_b_b_tree_prod_fun$ B$) B_b_tree_prod$) +(declare-fun fun_app$ef (A_a_tree_a_tree_prod_prod_a_a_tree_a_tree_prod_prod_fun$ A_a_tree_a_tree_prod_prod$) A_a_tree_a_tree_prod_prod$) +(declare-fun fun_app$eg (A_a_tree_a_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$ A_a_tree_a_tree_prod_prod$) B_b_tree_b_tree_prod_prod$) +(declare-fun fun_app$eh (A_b_fun_a_b_b_prod_fun_fun$ A_b_fun$) A_b_b_prod_fun$) +(declare-fun fun_app$ei (A_a_a_prod_fun_a_b_b_prod_fun_fun$ A_a_a_prod_fun$) A_b_b_prod_fun$) +(declare-fun fun_app$ej (B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun_b_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun_fun$ B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$) B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$) +(declare-fun fun_app$ek (B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun_b_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun_fun$ B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$) B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$) +(declare-fun fun_app$el (A_a_sum_b_b_sum_fun$ A_a_sum$) B_b_sum$) +(declare-fun fun_app$em (A_a_sum_a_a_sum_fun$ A_a_sum$) A_a_sum$) +(declare-fun fun_app$en (B_b_tree_sum_b_b_tree_sum_fun$ B_b_tree_sum$) B_b_tree_sum$) +(declare-fun fun_app$eo (B_tree_b_sum_b_tree_b_sum_fun$ B_tree_b_sum$) B_tree_b_sum$) +(declare-fun fun_app$ep (B_tree_b_tree_sum_b_tree_b_tree_sum_fun$ B_tree_b_tree_sum$) B_tree_b_tree_sum$) +(declare-fun fun_app$eq (A_b_fun_a_b_fun_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_fun$ A_b_fun_a_b_fun_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) +(declare-fun fun_app$er (B_tree_b_tree_fun_b_tree_b_fun_fun$ B_tree_b_tree_fun$) B_tree_b_fun$) +(declare-fun fun_app$es (B_b_tree_sum_b_fun$ B_b_tree_sum$) B$) +(declare-fun fun_app$et (B_tree_b_sum_b_tree_fun$ B_tree_b_sum$) B_tree$) +(declare-fun fun_app$eu (B_tree_b_tree_sum_b_tree_fun$ B_tree_b_tree_sum$) B_tree$) +(declare-fun fun_app$ev (A_bool_fun$ A$) Bool) +(declare-fun fun_app$ew (B_bool_fun$ B$) Bool) +(declare-fun fun_app$ex (B_b_bool_fun_fun$ B$) B_bool_fun$) +(declare-fun fun_app$ey (B_b_fun_b_b_bool_fun_fun_fun$ B_b_fun$) B_b_bool_fun_fun$) +(declare-fun fun_app$ez (B_b_b_fun_b_b_bool_fun_fun_fun_fun$ B$) B_b_fun_b_b_bool_fun_fun_fun$) +(declare-fun fun_app$fa (B_b_fun_b_b_b_fun_b_b_bool_fun_fun_fun_fun_fun$ B_b_fun$) B_b_b_fun_b_b_bool_fun_fun_fun_fun$) +(declare-fun fun_app$fb (B_tree_b_tree_bool_fun_fun$ B_tree$) B_tree_bool_fun$) +(declare-fun fun_app$fc (B_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun$ B_tree_b_tree_fun$) B_tree_b_tree_bool_fun_fun$) +(declare-fun fun_app$fd (B_tree_b_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun_fun$ B_tree$) B_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun$) +(declare-fun fun_app$fe (B_tree_b_tree_fun_b_tree_b_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun_fun_fun$ B_tree_b_tree_fun$) B_tree_b_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun_fun$) +(declare-fun fun_app$ff (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_bool_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_bool_fun$) +(declare-fun fun_app$fg (B_b_b_prod_fun_b_b_fun_fun$ B_b_b_prod_fun$) B_b_fun$) +(declare-fun fun_app$fh (B_tree_b_tree_b_tree_prod_fun_b_tree_b_tree_fun_fun$ B_tree_b_tree_b_tree_prod_fun$) B_tree_b_tree_fun$) +(declare-fun fun_app$fi (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) +(declare-fun fun_app$fj (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) +(declare-fun map_prod$a (B_tree_a_b_fun_sum_b_tree_fun$) B_tree_a_b_fun_sum_b_tree_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun_fun$) +(declare-fun map_prod$b (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_fun$) +(declare-fun map_prod$c (B_b_tree_a_b_fun_sum_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) +(declare-fun map_prod$d (B_tree_a_b_fun_sum_b_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) +(declare-fun map_prod$e (B_b_fun$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) +(declare-fun map_prod$f (B_b_fun$ B_b_fun$) B_b_prod_b_b_prod_fun$) +(declare-fun map_prod$g (A_b_fun$ A_b_fun$) A_a_prod_b_b_prod_fun$) +(declare-fun map_prod$h (A_a_fun$ A_a_fun$) A_a_prod_a_a_prod_fun$) +(declare-fun map_prod$i (A_tree_b_fun$ A_tree_b_fun$ A_tree_a_tree_prod$) B_b_prod$) +(declare-fun map_prod$j (B_b_fun$ B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_prod$k (B_tree_b_tree_fun$) B_tree_b_tree_fun_b_tree_b_tree_prod_b_tree_b_tree_prod_fun_fun$) +(declare-fun map_prod$l (B_b_fun$ B_tree_b_tree_fun$) B_b_tree_prod_b_b_tree_prod_fun$) +(declare-fun map_prod$m (B_tree_b_tree_fun$ B_b_fun$) B_tree_b_prod_b_tree_b_prod_fun$) +(declare-fun map_prod$n (B_b_tree_fun$ B_b_fun$) B_b_prod_b_tree_b_prod_fun$) +(declare-fun map_prod$o (B_tree_b_fun$ B_b_fun$) B_tree_b_prod_b_b_prod_fun$) +(declare-fun map_prod$p (B_b_tree_fun$ B_tree_b_tree_fun$) B_b_tree_prod_b_tree_b_tree_prod_fun$) +(declare-fun map_prod$q (B_tree_b_fun$ B_tree_b_tree_fun$) B_tree_b_tree_prod_b_b_tree_prod_fun$) +(declare-fun map_tree$a (B_b_fun$) B_tree_b_tree_fun$) +(declare-fun map_tree$b (B_a_fun$) B_tree_a_tree_fun$) +(declare-fun map_tree$c (A_a_fun$) A_tree_a_tree_fun$) +(declare-fun map_tree$d (A_b_b_prod_fun$) A_tree_b_b_prod_tree_fun$) +(declare-fun map_tree$e (A_a_sum_a_fun$) A_a_sum_tree_a_tree_fun$) +(declare-fun map_tree$f (A_a_sum_b_fun$) A_a_sum_tree_b_tree_fun$) +(declare-fun map_tree$g (B_tree_b_tree_fun$) B_tree_tree_b_tree_tree_fun$) +(declare-fun map_tree$h (B_b_sum_b_b_sum_fun$) B_b_sum_tree_b_b_sum_tree_fun$) +(declare-fun map_tree$i (B_tree_b_tree_fun_b_tree_b_tree_fun_fun$) B_tree_b_tree_fun_tree_b_tree_b_tree_fun_tree_fun$) +(declare-fun map_tree$j (B_b_fun_b_b_fun_fun$) B_b_fun_tree_b_b_fun_tree_fun$) +(declare-fun map_tree$k (A_b_fun_a_b_fun_fun$) A_b_fun_tree_a_b_fun_tree_fun$) +(declare-fun pred_tree$ (A_bool_fun$ A_tree$) Bool) +(declare-fun corec_tree$ (A_a_fun$) A_bool_fun_a_a_tree_fun_a_a_fun_a_bool_fun_a_a_tree_fun_a_a_fun_a_a_tree_fun_fun_fun_fun_fun_fun_fun$) +(declare-fun ctor_tree$a (A_a_tree_a_tree_prod_prod$) A_tree$) +(declare-fun dtor_tree$a () A_tree_a_a_tree_a_tree_prod_prod_fun$) +(declare-fun corec_tree$a (A_b_fun$ A_bool_fun$ A_b_tree_fun$ A_a_fun$ A_bool_fun$ A_b_tree_fun$ A_a_fun$) A_b_tree_fun$) +(declare-fun corec_tree$b (A_b_fun_b_fun$) A_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_bool_fun_a_b_fun_b_tree_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun_fun_fun_fun_fun$) +(declare-fun unfold_tree$ (A_b_fun_b_fun$) A_b_fun_a_b_fun_fun_a_b_fun_a_b_fun_fun_a_b_fun_b_tree_fun_fun_fun$) +(declare-fun map_pre_tree$ (B_b_fun$ B_tree_a_b_fun_sum_b_tree_fun$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun tree_recurse$ (B_b_fun$) B_b_fun_b_b_tree_fun_fun$) +(declare-fun unfold_tree$a (A_a_fun$) A_a_fun_a_a_fun_a_a_tree_fun_fun_fun$) +(declare-fun unfold_tree$b (A_b_fun$ A_a_fun$ A_a_fun$ A$) B_tree$) +(declare-fun unfold_tree$c (B_b_fun_b_fun$ B_b_fun_b_b_fun_fun$ B_b_fun_b_b_fun_fun$ B_b_fun$) B_tree$) +(declare-fun unfold_tree$d (B_tree_b_tree_fun_b_tree_fun$ B_tree_b_tree_fun_b_tree_b_tree_fun_fun$ B_tree_b_tree_fun_b_tree_b_tree_fun_fun$ B_tree_b_tree_fun$) B_tree_tree$) +(declare-fun map_pre_tree$a (A_b_fun$ A_b_fun$) A_a_a_prod_prod_b_b_b_prod_prod_fun$) +(declare-fun map_pre_tree$b (A_a_fun$ A_a_fun$) A_a_a_prod_prod_a_a_a_prod_prod_fun$) +(declare-fun map_pre_tree$c (B_b_fun$ B_b_fun$) B_b_b_prod_prod_b_b_b_prod_prod_fun$) +(declare-fun map_pre_tree$d (B_b_fun$ B_tree_b_tree_fun$) B_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_pre_tree$e (B_tree_b_tree_fun$ B_b_fun$) B_tree_b_b_prod_prod_b_tree_b_b_prod_prod_fun$) +(declare-fun map_pre_tree$f (B_tree_b_tree_fun$ B_tree_b_tree_fun$) B_tree_b_tree_b_tree_prod_prod_b_tree_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_pre_tree$g (A_b_fun$ B_b_fun$) A_b_b_prod_prod_b_b_b_prod_prod_fun$) +(declare-fun map_pre_tree$h (A_b_fun$ B_tree_b_tree_fun$) A_b_tree_b_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_pre_tree$i (A_a_fun$ B_b_fun$) A_b_b_prod_prod_a_b_b_prod_prod_fun$) +(declare-fun map_pre_tree$j (A_a_fun$ B_tree_b_tree_fun$) A_b_tree_b_tree_prod_prod_a_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_pre_tree$k (A_a_fun$ A_tree_a_tree_fun$) A_a_tree_a_tree_prod_prod_a_a_tree_a_tree_prod_prod_fun$) +(declare-fun map_pre_tree$l (A_b_fun$ A_tree_b_tree_fun$) A_a_tree_a_tree_prod_prod_b_b_tree_b_tree_prod_prod_fun$) +(declare-fun map_pre_tree$m (A_b_fun$ A_tree_b_sum_b_tree_b_sum_fun$) A_a_tree_b_sum_a_tree_b_sum_prod_prod_b_b_tree_b_sum_b_tree_b_sum_prod_prod_fun$) +(declare-fun map_pre_tree$n (A_b_fun$ A_tree_b_tree_sum_b_tree_b_tree_sum_fun$) A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_b_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod_fun$) +(declare-fun map_pre_tree$o (A_a_fun$ A_tree_b_sum_a_tree_b_sum_fun$) A_a_tree_b_sum_a_tree_b_sum_prod_prod_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$) +(declare-fun map_pre_tree$p (A_a_fun$ A_tree_b_tree_sum_a_tree_b_tree_sum_fun$) A_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$) +(declare-fun tree_recurse$a (B_tree_b_tree_fun$ B_tree_b_tree_fun$ B_tree$) B_tree_tree$) +(declare-fun tree_recurse$b (A_a_fun$) A_a_fun_a_a_tree_fun_fun$) +(declare-fun dtor_corec_tree$ (A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) A_b_fun_b_tree_fun$) +(declare-fun dtor_corec_tree$a (B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$) B_a_tree_fun$) +(declare-fun dtor_corec_tree$b (B_b_b_tree_b_sum_b_tree_b_sum_prod_prod_fun$) B_b_tree_fun$) +(declare-fun dtor_corec_tree$c (B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$) B_tree_a_tree_fun$) +(declare-fun dtor_corec_tree$d (B_tree_b_b_tree_b_tree_sum_b_tree_b_tree_sum_prod_prod_fun$) B_tree_b_tree_fun$) +(declare-fun dtor_unfold_tree$ (B_a_b_b_prod_prod_fun$) B_a_tree_fun$) +(declare-fun dtor_unfold_tree$a (B_b_b_b_prod_prod_fun$) B_b_tree_fun$) +(declare-fun dtor_unfold_tree$b (B_tree_a_b_tree_b_tree_prod_prod_fun$) B_tree_a_tree_fun$) +(declare-fun dtor_unfold_tree$c (B_tree_b_b_tree_b_tree_prod_prod_fun$) B_tree_b_tree_fun$) +(declare-fun iso_tuple_update_accessor_eq_assist$ (B_b_fun_b_b_fun_fun$) B_b_fun_b_b_b_fun_b_b_bool_fun_fun_fun_fun_fun$) +(declare-fun iso_tuple_update_accessor_eq_assist$a (B_tree_b_tree_fun_b_tree_b_tree_fun_fun$) B_tree_b_tree_fun_b_tree_b_tree_b_tree_fun_b_tree_b_tree_bool_fun_fun_fun_fun_fun$) +(assert (forall ((?v0 B_tree$)) (! (= (fun_app$ uvk$ ?v0) (pair$ ?v0 ?v0)) :pattern ((fun_app$ uvk$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (! (= (fun_app$a uvl$ ?v0) (pair$b ?v0 ?v0)) :pattern ((fun_app$a uvl$ ?v0))))) +(assert (forall ((?v0 B$)) (! (= (fun_app$b uvj$ ?v0) (pair$f ?v0 ?v0)) :pattern ((fun_app$b uvj$ ?v0))))) +(assert (forall ((?v0 A_b_fun$)) (! (= (fun_app$c uu$ ?v0) (fun_app$d (map_tree$ ?v0) t$)) :pattern ((fun_app$c uu$ ?v0))))) +(assert (forall ((?v0 B_tree_b_tree_prod$)) (! (= (fun_app$e uvg$ ?v0) (snd$ ?v0)) :pattern ((fun_app$e uvg$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$f uvh$ ?v0) (snd$b ?v0)) :pattern ((fun_app$f uvh$ ?v0))))) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (! (= (fun_app$g uve$ ?v0) (snd$a ?v0)) :pattern ((fun_app$g uve$ ?v0))))) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (! (= (fun_app$h uvf$ ?v0) (snd$c ?v0)) :pattern ((fun_app$h uvf$ ?v0))))) +(assert (forall ((?v0 B_b_prod$)) (! (= (fun_app$i uvi$ ?v0) (snd$f ?v0)) :pattern ((fun_app$i uvi$ ?v0))))) +(assert (forall ((?v0 B_tree_b_tree_prod$)) (! (= (fun_app$e uvc$ ?v0) (fst$ ?v0)) :pattern ((fun_app$e uvc$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$f uvd$ ?v0) (fst$b ?v0)) :pattern ((fun_app$f uvd$ ?v0))))) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (! (= (fun_app$j uva$ ?v0) (fst$a ?v0)) :pattern ((fun_app$j uva$ ?v0))))) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (! (= (fun_app$k uvb$ ?v0) (fst$c ?v0)) :pattern ((fun_app$k uvb$ ?v0))))) +(assert (forall ((?v0 B_b_prod$)) (! (= (fun_app$i uvm$ ?v0) (fst$f ?v0)) :pattern ((fun_app$i uvm$ ?v0))))) +(assert (forall ((?v0 A_b_fun$)) (! (= (fun_app$l uun$ ?v0) (inr$ ?v0)) :pattern ((fun_app$l uun$ ?v0))))) +(assert (forall ((?v0 B_tree$)) (! (= (fun_app$m uur$ ?v0) (inl$ ?v0)) :pattern ((fun_app$m uur$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$)) (! (= (fun_app$a (fun_app$n uvq$ ?v0) ?v1) (pair$b ?v0 ?v1)) :pattern ((fun_app$a (fun_app$n uvq$ ?v0) ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$o (fun_app$p uvp$ ?v0) ?v1) (pair$c ?v0 ?v1)) :pattern ((fun_app$o (fun_app$p uvp$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B$)) (! (= (fun_app$q (fun_app$r uvn$ ?v0) ?v1) (pair$c ?v1 ?v0)) :pattern ((fun_app$q (fun_app$r uvn$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$)) (! (= (fun_app$a (fun_app$n uvo$ ?v0) ?v1) (pair$b ?v1 ?v0)) :pattern ((fun_app$a (fun_app$n uvo$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$)) (! (= (fun_app$s (uux$ ?v0) ?v1) (fun_app$s (comp$ ?v1) ?v0)) :pattern ((fun_app$s (uux$ ?v0) ?v1))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$)) (! (= (fun_app$t (uuv$ ?v0) ?v1) (fun_app$t (comp$a ?v1) ?v0)) :pattern ((fun_app$t (uuv$ ?v0) ?v1))))) +(assert (forall ((?v0 A_a_fun$) (?v1 A_b_fun$)) (! (= (fun_app$u (uup$ ?v0) ?v1) (fun_app$v (comp$b ?v1) ?v0)) :pattern ((fun_app$u (uup$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 A_b_fun$)) (! (= (fun_app$c (uut$ ?v0) ?v1) (fun_app$w ?v0 (inr$ ?v1))) :pattern ((fun_app$c (uut$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree$)) (! (= (fun_app$x (uus$ ?v0) ?v1) (fun_app$w ?v0 (inl$ ?v1))) :pattern ((fun_app$x (uus$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree$) (?v1 B_tree_b_tree_fun$)) (! (= (fun_app$y (uuw$ ?v0) ?v1) (fun_app$x ?v1 ?v0)) :pattern ((fun_app$y (uuw$ ?v0) ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_b_fun$)) (! (= (fun_app$z (uuu$ ?v0) ?v1) (fun_app$aa ?v1 ?v0)) :pattern ((fun_app$z (uuu$ ?v0) ?v1))))) +(assert (forall ((?v0 A$) (?v1 A_b_fun$)) (! (= (fun_app$ab (uuo$ ?v0) ?v1) (fun_app$ac ?v1 ?v0)) :pattern ((fun_app$ab (uuo$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (! (= (fun_app$ad (fun_app$ae (uuz$ ?v0) ?v1) ?v2) (member$ (pair$b ?v1 ?v2) ?v0)) :pattern ((fun_app$ad (fun_app$ae (uuz$ ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$af (fun_app$ag (uuy$ ?v0) ?v1) ?v2) (member$a (pair$c ?v1 ?v2) ?v0)) :pattern ((fun_app$af (fun_app$ag (uuy$ ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree$)) (! (= (fun_app$x (fun_app$s (uul$ ?v0) ?v1) ?v2) (fun_app$x ?v0 (fun_app$x ?v1 ?v2))) :pattern ((fun_app$x (fun_app$s (uul$ ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 A_b_fun$)) (! (= (fun_app$c (fun_app$ah (uum$ ?v0) ?v1) ?v2) (fun_app$x ?v0 (fun_app$c ?v1 ?v2))) :pattern ((fun_app$c (fun_app$ah (uum$ ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (! (= (fun_app$ai (fun_app$aj (uvs$ ?v0 ?v1) ?v2) ?v3) (pair$ (fun_app$w ?v0 ?v2) (fun_app$w ?v1 ?v3))) :pattern ((fun_app$ai (fun_app$aj (uvs$ ?v0 ?v1) ?v2) ?v3))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$ak (fun_app$al (uvr$ ?v0 ?v1) ?v2) ?v3) (pair$a (fun_app$aa ?v0 ?v2) (fun_app$am ?v1 ?v3))) :pattern ((fun_app$ak (fun_app$al (uvr$ ?v0 ?v1) ?v2) ?v3))))) +(assert (forall ((?v0 A_b_fun_b_fun$) (?v1 A_b_fun_bool_fun$) (?v2 A_b_fun_b_tree_fun$) (?v3 A_b_fun_a_b_fun_fun$) (?v4 A_b_fun_bool_fun$) (?v5 A_b_fun_b_tree_fun$) (?v6 A_b_fun_a_b_fun_fun$) (?v7 A_b_fun$)) (! (= (fun_app$an (fun_app$ao (fun_app$ap (fun_app$aq (fun_app$ar (fun_app$as (fun_app$at (uuq$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) ?v6) ?v7) (id_bnf$ (pair$c (fun_app$ab ?v0 ?v7) (pair$b (ite (fun_app$au ?v1 ?v7) (inl$ (fun_app$c ?v2 ?v7)) (inr$ (fun_app$u ?v3 ?v7))) (ite (fun_app$au ?v4 ?v7) (inl$ (fun_app$c ?v5 ?v7)) (inr$ (fun_app$u ?v6 ?v7))))))) :pattern ((fun_app$an (fun_app$ao (fun_app$ap (fun_app$aq (fun_app$ar (fun_app$as (fun_app$at (uuq$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) ?v6) ?v7))))) +(assert (forall ((?v0 B_tree$) (?v1 B_tree$)) (! (= (fun_app$x (uuh$ ?v0) ?v1) ?v0) :pattern ((fun_app$x (uuh$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree$) (?v1 A_b_fun$)) (! (= (fun_app$c (uui$ ?v0) ?v1) ?v0) :pattern ((fun_app$c (uui$ ?v0) ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_tree$)) (! (= (fun_app$av (uuf$ ?v0) ?v1) ?v0) :pattern ((fun_app$av (uuf$ ?v0) ?v1))))) +(assert (forall ((?v0 B$) (?v1 B$)) (! (= (fun_app$aa (uud$ ?v0) ?v1) ?v0) :pattern ((fun_app$aa (uud$ ?v0) ?v1))))) +(assert (forall ((?v0 B$) (?v1 A$)) (! (= (fun_app$ac (uue$ ?v0) ?v1) ?v0) :pattern ((fun_app$ac (uue$ ?v0) ?v1))))) +(assert (forall ((?v0 A$) (?v1 A$)) (! (= (fun_app$aw (uug$ ?v0) ?v1) ?v0) :pattern ((fun_app$aw (uug$ ?v0) ?v1))))) +(assert (forall ((?v0 B_tree$)) (! (= (fun_app$x uub$ ?v0) ?v0) :pattern ((fun_app$x uub$ ?v0))))) +(assert (forall ((?v0 B_tree_b_tree_prod$)) (! (= (fun_app$ax uuj$ ?v0) ?v0) :pattern ((fun_app$ax uuj$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$ay uuk$ ?v0) ?v0) :pattern ((fun_app$ay uuk$ ?v0))))) +(assert (forall ((?v0 B$)) (! (= (fun_app$aa uua$ ?v0) ?v0) :pattern ((fun_app$aa uua$ ?v0))))) +(assert (forall ((?v0 A$)) (! (= (fun_app$aw uuc$ ?v0) ?v0) :pattern ((fun_app$aw uuc$ ?v0))))) +(assert (not (forall ((?v0 A_b_fun$)) (= (id_bnf$a (fun_app$az (map_prod$ id$ (fun_app$ba (map_prod$a (fun_app$bb (case_sum$ id$a) uu$)) (fun_app$bb (case_sum$ id$a) uu$))) (id_bnf$ (id_bnf$ (pair$c (fun_app$ac ?v0 x$) (pair$b (inr$ (fun_app$v (comp$b ?v0) l$)) (inr$ (fun_app$v (comp$b ?v0) r$)))))))) (fun_app$bc dtor_tree$ (fun_app$d (map_tree$ ?v0) t$))) ))) +(assert (forall ((?v0 A_tree$) (?v1 A_tree$)) (= (= (fun_app$bd dtor_tree$a ?v0) (fun_app$bd dtor_tree$a ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 B_tree$) (?v1 B_tree$)) (= (= (fun_app$bc dtor_tree$ ?v0) (fun_app$bc dtor_tree$ ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A_tree$)) (= (fun_app$x (map_tree$a ?v0) (fun_app$d (map_tree$ ?v1) ?v2)) (fun_app$d (map_tree$ (fun_app$u (comp$c ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 B_a_fun$) (?v1 A_b_fun$) (?v2 A_tree$)) (= (fun_app$be (map_tree$b ?v0) (fun_app$d (map_tree$ ?v1) ?v2)) (fun_app$bf (map_tree$c (fun_app$bg (comp$d ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_tree$)) (= (fun_app$d (map_tree$ ?v0) (fun_app$bf (map_tree$c ?v1) ?v2)) (fun_app$d (map_tree$ (fun_app$v (comp$b ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A_tree$)) (= (fun_app$bf (map_tree$c ?v0) (fun_app$bf (map_tree$c ?v1) ?v2)) (fun_app$bf (map_tree$c (fun_app$bh (comp$e ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_a_fun$) (?v2 B_tree$)) (= (fun_app$d (map_tree$ ?v0) (fun_app$be (map_tree$b ?v1) ?v2)) (fun_app$x (map_tree$a (fun_app$bi (comp$f ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_a_fun$) (?v1 B_a_fun$) (?v2 B_tree$)) (= (fun_app$bf (map_tree$c ?v0) (fun_app$be (map_tree$b ?v1) ?v2)) (fun_app$be (map_tree$b (fun_app$bj (comp$g ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 B_a_fun$) (?v1 B_b_fun$) (?v2 B_tree$)) (= (fun_app$be (map_tree$b ?v0) (fun_app$x (map_tree$a ?v1) ?v2)) (fun_app$be (map_tree$b (fun_app$bk (comp$h ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B_tree$)) (= (fun_app$x (map_tree$a ?v0) (fun_app$x (map_tree$a ?v1) ?v2)) (fun_app$x (map_tree$a (fun_app$t (comp$a ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_b_b_prod_fun$) (?v1 A_a_fun$) (?v2 A_tree$)) (= (fun_app$bl (map_tree$d ?v0) (fun_app$bf (map_tree$c ?v1) ?v2)) (fun_app$bl (map_tree$d (fun_app$bm (comp$i ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_sum_a_fun$) (?v2 A_a_sum_tree$)) (= (fun_app$d (map_tree$ ?v0) (fun_app$bn (map_tree$e ?v1) ?v2)) (fun_app$bo (map_tree$f (comp$j ?v0 ?v1)) ?v2)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$)) (= (map_tree$ (fun_app$u (comp$c ?v0) ?v1)) (fun_app$bp (comp$k (map_tree$a ?v0)) (map_tree$ ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$)) (= (map_tree$ (fun_app$v (comp$b ?v0) ?v1)) (fun_app$bq (comp$l (map_tree$ ?v0)) (map_tree$c ?v1))) )) +(assert (forall ((?v0 B_a_fun$) (?v1 A_b_fun$)) (= (map_tree$c (fun_app$bg (comp$d ?v0) ?v1)) (fun_app$br (comp$m (map_tree$b ?v0)) (map_tree$ ?v1))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$)) (= (map_tree$c (fun_app$bh (comp$e ?v0) ?v1)) (fun_app$bs (comp$n (map_tree$c ?v0)) (map_tree$c ?v1))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 B_a_fun$)) (= (map_tree$b (fun_app$bj (comp$g ?v0) ?v1)) (comp$o (map_tree$c ?v0) (map_tree$b ?v1))) )) +(assert (forall ((?v0 B_a_fun$) (?v1 B_b_fun$)) (= (map_tree$b (fun_app$bk (comp$h ?v0) ?v1)) (comp$p (map_tree$b ?v0) (map_tree$a ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_a_fun$)) (= (map_tree$a (fun_app$bi (comp$f ?v0) ?v1)) (fun_app$bt (comp$q (map_tree$ ?v0)) (map_tree$b ?v1))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$)) (= (map_tree$a (fun_app$t (comp$a ?v0) ?v1)) (fun_app$s (comp$ (map_tree$a ?v0)) (map_tree$a ?v1))) )) +(assert (forall ((?v0 A_b_b_prod_fun$) (?v1 A_a_fun$)) (= (map_tree$d (fun_app$bm (comp$i ?v0) ?v1)) (comp$r (map_tree$d ?v0) (map_tree$c ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_sum_a_fun$)) (= (map_tree$f (comp$j ?v0 ?v1)) (comp$s (map_tree$ ?v0) (map_tree$e ?v1))) )) +(assert (forall ((?v0 B_tree$)) (= (fun_app$x (map_tree$a uua$) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_tree$)) (= (fun_app$bu (map_tree$g uub$) ?v0) ?v0) )) +(assert (forall ((?v0 A_tree$)) (= (fun_app$bf (map_tree$c uuc$) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_sum_tree$)) (= (fun_app$bv (map_tree$h id$b) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_tree_fun_tree$)) (= (fun_app$bw (map_tree$i id$c) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_fun_tree$)) (= (fun_app$bx (map_tree$j id$d) ?v0) ?v0) )) +(assert (forall ((?v0 A_b_fun_tree$)) (= (fun_app$by (map_tree$k id$e) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree$)) (= (fun_app$x (map_tree$a id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_tree$)) (= (fun_app$bu (map_tree$g id$a) ?v0) ?v0) )) +(assert (forall ((?v0 A_tree$)) (= (fun_app$bf (map_tree$c id$f) ?v0) ?v0) )) +(assert (= (map_tree$h id$b) id$g)) +(assert (= (map_tree$i id$c) id$h)) +(assert (= (map_tree$j id$d) id$i)) +(assert (= (map_tree$k id$e) id$j)) +(assert (= (map_tree$a id$) id$a)) +(assert (= (map_tree$g id$a) id$k)) +(assert (= (map_tree$c id$f) id$l)) +(assert (forall ((?v0 A_a_tree_a_tree_prod_prod$)) (=> (forall ((?v1 A_tree$)) (=> (= ?v0 (fun_app$bd dtor_tree$a ?v1)) false) ) false) )) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (=> (forall ((?v1 B_tree$)) (=> (= ?v0 (fun_app$bc dtor_tree$ ?v1)) false) ) false) )) +(assert (= t$ (node$a x$ (fun_app$bf (map_tree$c l$) t$) (fun_app$bf (map_tree$c r$) t$)))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (! (= (fun_app$am (fun_app$ba (map_prod$a ?v0) ?v1) (pair$b ?v2 ?v3)) (pair$ (fun_app$w ?v0 ?v2) (fun_app$w ?v1 ?v3))) :pattern ((fun_app$am (fun_app$ba (map_prod$a ?v0) ?v1) (pair$b ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$az (map_prod$ ?v0 ?v1) (pair$c ?v2 ?v3)) (pair$a (fun_app$aa ?v0 ?v2) (fun_app$am ?v1 ?v3))) :pattern ((fun_app$az (map_prod$ ?v0 ?v1) (pair$c ?v2 ?v3)))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (! (= (fun_app$ay (fun_app$bz (map_prod$b ?v0) ?v1) (pair$b ?v2 ?v3)) (pair$b (fun_app$ca ?v0 ?v2) (fun_app$ca ?v1 ?v3))) :pattern ((fun_app$ay (fun_app$bz (map_prod$b ?v0) ?v1) (pair$b ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (map_prod$c ?v0 ?v1 (pair$c ?v2 ?v3)) (pair$b (fun_app$cb ?v0 ?v2) (fun_app$f ?v1 ?v3))) :pattern ((map_prod$c ?v0 ?v1 (pair$c ?v2 ?v3)))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (! (= (map_prod$d ?v0 ?v1 (pair$b ?v2 ?v3)) (pair$c (fun_app$cc ?v0 ?v2) (fun_app$a ?v1 ?v3))) :pattern ((map_prod$d ?v0 ?v1 (pair$b ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$cd (map_prod$e ?v0 ?v1) (pair$c ?v2 ?v3)) (pair$c (fun_app$aa ?v0 ?v2) (fun_app$ay ?v1 ?v3))) :pattern ((fun_app$cd (map_prod$e ?v0 ?v1) (pair$c ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B$) (?v3 B$)) (! (= (fun_app$ce (map_prod$f ?v0 ?v1) (pair$f ?v2 ?v3)) (pair$f (fun_app$aa ?v0 ?v2) (fun_app$aa ?v1 ?v3))) :pattern ((fun_app$ce (map_prod$f ?v0 ?v1) (pair$f ?v2 ?v3)))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A$) (?v3 A$)) (! (= (fun_app$cf (map_prod$g ?v0 ?v1) (pair$g ?v2 ?v3)) (pair$f (fun_app$ac ?v0 ?v2) (fun_app$ac ?v1 ?v3))) :pattern ((fun_app$cf (map_prod$g ?v0 ?v1) (pair$g ?v2 ?v3)))))) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A$) (?v3 A$)) (! (= (fun_app$cg (map_prod$h ?v0 ?v1) (pair$g ?v2 ?v3)) (pair$g (fun_app$aw ?v0 ?v2) (fun_app$aw ?v1 ?v3))) :pattern ((fun_app$cg (map_prod$h ?v0 ?v1) (pair$g ?v2 ?v3)))))) +(assert (forall ((?v0 A_tree_b_fun$) (?v1 A_tree_b_fun$) (?v2 A_tree$) (?v3 A_tree$)) (! (= (map_prod$i ?v0 ?v1 (pair$d ?v2 ?v3)) (pair$f (fun_app$ch ?v0 ?v2) (fun_app$ch ?v1 ?v3))) :pattern ((map_prod$i ?v0 ?v1 (pair$d ?v2 ?v3)))))) +(assert (forall ((?v0 A_b_b_prod_fun$)) (= (fun_app$bm (comp$i ?v0) id$f) ?v0) )) +(assert (forall ((?v0 A_a_fun$)) (= (fun_app$bh (comp$e ?v0) id$f) ?v0) )) +(assert (forall ((?v0 A_b_fun$)) (= (fun_app$v (comp$b ?v0) id$f) ?v0) )) +(assert (forall ((?v0 A_b_fun$)) (= (fun_app$u (comp$c id$) ?v0) ?v0) )) +(assert (forall ((?v0 A_a_fun$)) (= (fun_app$bh (comp$e id$f) ?v0) ?v0) )) +(assert (forall ((?v0 A_b_fun$)) (= (fun_app$u (comp$c id$) ?v0) ?v0) )) +(assert (forall ((?v0 A_a_fun$)) (= (fun_app$bh (comp$e id$f) ?v0) ?v0) )) +(assert (forall ((?v0 B$) (?v1 B_b_sum$)) (= (fun_app$ci (case_sum$a (uud$ ?v0) (uud$ ?v0)) ?v1) ?v0) )) +(assert (forall ((?v0 B$) (?v1 A_b_tree_sum$)) (= (case_sum$b (uue$ ?v0) (uuf$ ?v0) ?v1) ?v0) )) +(assert (forall ((?v0 B$) (?v1 A_b_sum$)) (= (case_sum$c (uue$ ?v0) (uud$ ?v0) ?v1) ?v0) )) +(assert (forall ((?v0 B$) (?v1 A_a_sum$)) (= (fun_app$cj (case_sum$d (uue$ ?v0) (uue$ ?v0)) ?v1) ?v0) )) +(assert (forall ((?v0 A$) (?v1 A_a_sum$)) (= (fun_app$ck (fun_app$cl (case_sum$e (uug$ ?v0)) (uug$ ?v0)) ?v1) ?v0) )) +(assert (forall ((?v0 B_tree$) (?v1 B_tree_a_b_fun_sum$)) (= (fun_app$w (fun_app$bb (case_sum$ (uuh$ ?v0)) (uui$ ?v0)) ?v1) ?v0) )) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (= (fun_app$cm (map_prod$j uua$ uuj$) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (fun_app$cd (map_prod$e uua$ uuk$) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_prod$)) (= (fun_app$ce (map_prod$f uua$ uua$) ?v0) ?v0) )) +(assert (forall ((?v0 A_a_prod$)) (= (fun_app$cg (map_prod$h uuc$ uuc$) ?v0) ?v0) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$)) (= (= (inr$ ?v0) (inr$ ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$)) (= (= (inr$ ?v0) (inr$ ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 B_b_sum$)) (! (= (fun_app$cn id$b ?v0) ?v0) :pattern ((fun_app$cn id$b ?v0))))) +(assert (forall ((?v0 B_tree_b_tree_fun$)) (! (= (fun_app$s id$c ?v0) ?v0) :pattern ((fun_app$s id$c ?v0))))) +(assert (forall ((?v0 B_b_fun$)) (! (= (fun_app$t id$d ?v0) ?v0) :pattern ((fun_app$t id$d ?v0))))) +(assert (forall ((?v0 A_b_fun$)) (! (= (fun_app$u id$e ?v0) ?v0) :pattern ((fun_app$u id$e ?v0))))) +(assert (forall ((?v0 A$)) (! (= (fun_app$aw id$f ?v0) ?v0) :pattern ((fun_app$aw id$f ?v0))))) +(assert (forall ((?v0 B$)) (! (= (fun_app$aa id$ ?v0) ?v0) :pattern ((fun_app$aa id$ ?v0))))) +(assert (forall ((?v0 B_tree$)) (! (= (fun_app$x id$a ?v0) ?v0) :pattern ((fun_app$x id$a ?v0))))) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A$)) (! (= (fun_app$ac (fun_app$u (comp$c ?v0) ?v1) ?v2) (fun_app$aa ?v0 (fun_app$ac ?v1 ?v2))) :pattern ((fun_app$ac (fun_app$u (comp$c ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 B_a_fun$) (?v1 A_b_fun$) (?v2 A$)) (! (= (fun_app$aw (fun_app$bg (comp$d ?v0) ?v1) ?v2) (fun_app$co ?v0 (fun_app$ac ?v1 ?v2))) :pattern ((fun_app$aw (fun_app$bg (comp$d ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 A_b_b_prod_fun$) (?v1 A_a_fun$) (?v2 A$)) (! (= (fun_app$cp (fun_app$bm (comp$i ?v0) ?v1) ?v2) (fun_app$cp ?v0 (fun_app$aw ?v1 ?v2))) :pattern ((fun_app$cp (fun_app$bm (comp$i ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_sum_a_fun$) (?v2 A_a_sum$)) (! (= (fun_app$cj (comp$j ?v0 ?v1) ?v2) (fun_app$ac ?v0 (fun_app$ck ?v1 ?v2))) :pattern ((fun_app$cj (comp$j ?v0 ?v1) ?v2))))) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A$)) (! (= (fun_app$aw (fun_app$bh (comp$e ?v0) ?v1) ?v2) (fun_app$aw ?v0 (fun_app$aw ?v1 ?v2))) :pattern ((fun_app$aw (fun_app$bh (comp$e ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A$)) (! (= (fun_app$ac (fun_app$v (comp$b ?v0) ?v1) ?v2) (fun_app$ac ?v0 (fun_app$aw ?v1 ?v2))) :pattern ((fun_app$ac (fun_app$v (comp$b ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 A_tree$) (?v1 A_tree$) (?v2 A_tree$) (?v3 A_tree$)) (= (= (pair$d ?v0 ?v1) (pair$d ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v3 B$)) (= (= (pair$h ?v0 ?v1) (pair$h ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B_tree_b_tree_prod$) (?v2 B$) (?v3 B_tree_b_tree_prod$)) (= (= (pair$a ?v0 ?v1) (pair$a ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B$) (?v2 B$) (?v3 B$)) (= (= (pair$f ?v0 ?v1) (pair$f ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 A$) (?v1 A_tree_a_tree_prod$) (?v2 A$) (?v3 A_tree_a_tree_prod$)) (= (= (pair$e ?v0 ?v1) (pair$e ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (= (pair$c ?v0 ?v1) (pair$c ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (= (= (pair$b ?v0 ?v1) (pair$b ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 A_tree$) (?v1 A_tree$) (?v2 A_tree$) (?v3 A_tree$)) (= (= (pair$d ?v0 ?v1) (pair$d ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v3 B$)) (= (= (pair$h ?v0 ?v1) (pair$h ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B_tree_b_tree_prod$) (?v2 B$) (?v3 B_tree_b_tree_prod$)) (= (= (pair$a ?v0 ?v1) (pair$a ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B$) (?v2 B$) (?v3 B$)) (= (= (pair$f ?v0 ?v1) (pair$f ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 A$) (?v1 A_tree_a_tree_prod$) (?v2 A$) (?v3 A_tree_a_tree_prod$)) (= (= (pair$e ?v0 ?v1) (pair$e ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (= (pair$c ?v0 ?v1) (pair$c ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (= (= (pair$b ?v0 ?v1) (pair$b ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3))) )) +(assert (forall ((?v0 B$) (?v1 B_tree$) (?v2 B_tree$) (?v3 B$) (?v4 B_tree$) (?v5 B_tree$)) (= (= (node$ ?v0 ?v1 ?v2) (node$ ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5)))) )) +(assert (forall ((?v0 A$) (?v1 A_tree$) (?v2 A_tree$) (?v3 A$) (?v4 A_tree$) (?v5 A_tree$)) (= (= (node$a ?v0 ?v1 ?v2) (node$a ?v3 ?v4 ?v5)) (and (= ?v0 ?v3) (and (= ?v1 ?v4) (= ?v2 ?v5)))) )) +(assert (forall ((?v0 B_tree$)) (=> (forall ((?v1 B$) (?v2 B_tree$) (?v3 B_tree$)) (=> (= ?v0 (node$ ?v1 ?v2 ?v3)) false) ) false) )) +(assert (forall ((?v0 A_tree$)) (=> (forall ((?v1 A$) (?v2 A_tree$) (?v3 A_tree$)) (=> (= ?v0 (node$a ?v1 ?v2 ?v3)) false) ) false) )) +(assert (= (map_prod$j uua$ uuj$) id$m)) +(assert (= (map_prod$e uua$ uuk$) id$n)) +(assert (= (map_prod$f uua$ uua$) id$o)) +(assert (= (map_prod$h uuc$ uuc$) id$p)) +(assert (forall ((?v0 B_a_fun$) (?v1 B$) (?v2 B_tree$) (?v3 B_tree$)) (! (= (fun_app$be (map_tree$b ?v0) (node$ ?v1 ?v2 ?v3)) (node$a (fun_app$co ?v0 ?v1) (fun_app$be (map_tree$b ?v0) ?v2) (fun_app$be (map_tree$b ?v0) ?v3))) :pattern ((fun_app$be (map_tree$b ?v0) (node$ ?v1 ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B$) (?v2 B_tree$) (?v3 B_tree$)) (! (= (fun_app$x (map_tree$a ?v0) (node$ ?v1 ?v2 ?v3)) (node$ (fun_app$aa ?v0 ?v1) (fun_app$x (map_tree$a ?v0) ?v2) (fun_app$x (map_tree$a ?v0) ?v3))) :pattern ((fun_app$x (map_tree$a ?v0) (node$ ?v1 ?v2 ?v3)))))) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree$) (?v2 B_tree_tree$) (?v3 B_tree_tree$)) (! (= (fun_app$bu (map_tree$g ?v0) (node$d ?v1 ?v2 ?v3)) (node$d (fun_app$x ?v0 ?v1) (fun_app$bu (map_tree$g ?v0) ?v2) (fun_app$bu (map_tree$g ?v0) ?v3))) :pattern ((fun_app$bu (map_tree$g ?v0) (node$d ?v1 ?v2 ?v3)))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A$) (?v2 A_tree$) (?v3 A_tree$)) (! (= (fun_app$d (map_tree$ ?v0) (node$a ?v1 ?v2 ?v3)) (node$ (fun_app$ac ?v0 ?v1) (fun_app$d (map_tree$ ?v0) ?v2) (fun_app$d (map_tree$ ?v0) ?v3))) :pattern ((fun_app$d (map_tree$ ?v0) (node$a ?v1 ?v2 ?v3)))))) +(assert (forall ((?v0 A_a_fun$) (?v1 A$) (?v2 A_tree$) (?v3 A_tree$)) (! (= (fun_app$bf (map_tree$c ?v0) (node$a ?v1 ?v2 ?v3)) (node$a (fun_app$aw ?v0 ?v1) (fun_app$bf (map_tree$c ?v0) ?v2) (fun_app$bf (map_tree$c ?v0) ?v3))) :pattern ((fun_app$bf (map_tree$c ?v0) (node$a ?v1 ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_prod$)) (exists ((?v1 B$) (?v2 B$)) (= ?v0 (pair$f ?v1 ?v2)) ) )) +(assert (forall ((?v0 A_a_tree_a_tree_prod_prod$)) (exists ((?v1 A$) (?v2 A_tree_a_tree_prod$)) (= ?v0 (pair$e ?v1 ?v2)) ) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (exists ((?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= ?v0 (pair$c ?v1 ?v2)) ) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (exists ((?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (= ?v0 (pair$b ?v1 ?v2)) ) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (and (= (pair$c ?v0 ?v1) (pair$c ?v2 ?v3)) (=> (and (= ?v0 ?v2) (= ?v1 ?v3)) false)) false) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (=> (and (= (pair$b ?v0 ?v1) (pair$b ?v2 ?v3)) (=> (and (= ?v0 ?v2) (= ?v1 ?v3)) false)) false) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_bool_fun$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (=> (forall ((?v2 B$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (fun_app$cq ?v0 (pair$c ?v2 ?v3)) ) (fun_app$cq ?v0 ?v1)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (forall ((?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (fun_app$af ?v0 (pair$b ?v2 ?v3)) ) (fun_app$af ?v0 ?v1)) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (=> (forall ((?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (= ?v0 (pair$c ?v1 ?v2)) false) ) false) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (forall ((?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (=> (= ?v0 (pair$b ?v1 ?v2)) false) ) false) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A$)) (=> (= (fun_app$v (comp$b ?v0) ?v1) ?v2) (= (fun_app$ac ?v0 (fun_app$aw ?v1 ?v3)) (fun_app$ac ?v2 ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$) (?v4 A$)) (=> (= (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (= (fun_app$ac ?v0 (fun_app$aw ?v1 ?v4)) (fun_app$ac ?v2 (fun_app$aw ?v3 ?v4)))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$)) (=> (and (= (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (=> (forall ((?v4 A$)) (= (fun_app$ac ?v0 (fun_app$aw ?v1 ?v4)) (fun_app$ac ?v2 (fun_app$aw ?v3 ?v4))) ) false)) false) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A$)) (! (= (fun_app$ac (fun_app$v (comp$b ?v0) ?v1) ?v2) (fun_app$ac ?v0 (fun_app$aw ?v1 ?v2))) :pattern ((fun_app$ac (fun_app$v (comp$b ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$)) (= (fun_app$v (comp$b (fun_app$u (comp$c ?v0) ?v1)) ?v2) (fun_app$u (comp$c ?v0) (fun_app$v (comp$b ?v1) ?v2))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_a_fun$)) (= (fun_app$v (comp$b (fun_app$v (comp$b ?v0) ?v1)) ?v2) (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e ?v1) ?v2))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$)) (= (fun_app$u (comp$c ?v0) (fun_app$v (comp$b ?v1) ?v2)) (fun_app$v (comp$b (fun_app$u (comp$c ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_a_fun$)) (= (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e ?v1) ?v2)) (fun_app$v (comp$b (fun_app$v (comp$b ?v0) ?v1)) ?v2)) )) +(assert (forall ((?v0 B$)) (! (= (fun_app$aa id$ ?v0) ?v0) :pattern ((fun_app$aa id$ ?v0))))) +(assert (forall ((?v0 B_tree$)) (! (= (fun_app$x id$a ?v0) ?v0) :pattern ((fun_app$x id$a ?v0))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$)) (=> (= (inr$ ?v0) (inr$ ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 B_tree_b_tree_fun$) (?v3 A_b_fun_b_tree_fun$)) (=> (and (= (fun_app$bb (case_sum$ ?v0) ?v1) (fun_app$bb (case_sum$ ?v2) ?v3)) (=> (and (= ?v0 ?v2) (= ?v1 ?v3)) false)) false) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 A_b_fun_b_tree_fun$) (?v3 B_tree_a_b_fun_sum$)) (= (fun_app$x ?v0 (fun_app$w (fun_app$bb (case_sum$ ?v1) ?v2) ?v3)) (fun_app$w (fun_app$bb (case_sum$ (fun_app$s (uul$ ?v0) ?v1)) (fun_app$ah (uum$ ?v0) ?v2)) ?v3)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A$)) (=> (= (fun_app$v (comp$b ?v0) ?v1) (fun_app$u (comp$c id$) ?v2)) (= (fun_app$ac ?v0 (fun_app$aw ?v1 ?v3)) (fun_app$ac ?v2 ?v3))) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (=> (forall ((?v1 B$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (=> (= ?v0 (pair$c ?v1 (pair$b ?v2 ?v3))) false) ) false) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_bool_fun$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (=> (forall ((?v2 B$) (?v3 B_tree_a_b_fun_sum$) (?v4 B_tree_a_b_fun_sum$)) (fun_app$cq ?v0 (pair$c ?v2 (pair$b ?v3 ?v4))) ) (fun_app$cq ?v0 ?v1)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$)) (= (comp$t (map_prod$g ?v0 ?v1) (map_prod$h ?v2 ?v3)) (map_prod$g (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$)) (= (comp$u (map_prod$j ?v0 ?v1) (map_prod$ ?v2 ?v3)) (map_prod$ (fun_app$t (comp$a ?v0) ?v2) (fun_app$cr (comp$v ?v1) ?v3))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_fun$)) (= (fun_app$cr (comp$v (fun_app$cs (map_prod$k ?v0) ?v1)) (fun_app$ba (map_prod$a ?v2) ?v3)) (fun_app$ba (map_prod$a (fun_app$ct (comp$w ?v0) ?v2)) (fun_app$ct (comp$w ?v1) ?v3))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$)) (= (comp$x (map_prod$ ?v0 ?v1) (map_prod$e ?v2 ?v3)) (map_prod$ (fun_app$t (comp$a ?v0) ?v2) (fun_app$cu (comp$y ?v1) ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$)) (= (fun_app$cu (comp$y (fun_app$ba (map_prod$a ?v0) ?v1)) (fun_app$bz (map_prod$b ?v2) ?v3)) (fun_app$ba (map_prod$a (fun_app$cv (comp$z ?v0) ?v2)) (fun_app$cv (comp$z ?v1) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$)) (= (map_prod$g (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (comp$t (map_prod$g ?v0 ?v2) (map_prod$h ?v1 ?v3))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$)) (= (map_prod$ (fun_app$t (comp$a ?v0) ?v1) (fun_app$cr (comp$v ?v2) ?v3)) (comp$u (map_prod$j ?v0 ?v2) (map_prod$ ?v1 ?v3))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$)) (= (map_prod$ (fun_app$t (comp$a ?v0) ?v1) (fun_app$cu (comp$y ?v2) ?v3)) (comp$x (map_prod$ ?v0 ?v2) (map_prod$e ?v1 ?v3))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_b_tree_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_fun$)) (= (fun_app$ba (map_prod$a (fun_app$ct (comp$w ?v0) ?v1)) (fun_app$ct (comp$w ?v2) ?v3)) (fun_app$cr (comp$v (fun_app$cs (map_prod$k ?v0) ?v2)) (fun_app$ba (map_prod$a ?v1) ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$)) (= (fun_app$ba (map_prod$a (fun_app$cv (comp$z ?v0) ?v1)) (fun_app$cv (comp$z ?v2) ?v3)) (fun_app$cu (comp$y (fun_app$ba (map_prod$a ?v0) ?v2)) (fun_app$bz (map_prod$b ?v1) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_a_prod$)) (= (fun_app$cf (map_prod$g ?v0 ?v1) (fun_app$cg (map_prod$h ?v2 ?v3) ?v4)) (fun_app$cf (map_prod$g (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v4 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (fun_app$cm (map_prod$j ?v0 ?v1) (fun_app$az (map_prod$ ?v2 ?v3) ?v4)) (fun_app$az (map_prod$ (fun_app$t (comp$a ?v0) ?v2) (fun_app$cr (comp$v ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_fun$) (?v4 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (fun_app$ax (fun_app$cs (map_prod$k ?v0) ?v1) (fun_app$am (fun_app$ba (map_prod$a ?v2) ?v3) ?v4)) (fun_app$am (fun_app$ba (map_prod$a (fun_app$ct (comp$w ?v0) ?v2)) (fun_app$ct (comp$w ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) (?v4 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (fun_app$az (map_prod$ ?v0 ?v1) (fun_app$cd (map_prod$e ?v2 ?v3) ?v4)) (fun_app$az (map_prod$ (fun_app$t (comp$a ?v0) ?v2) (fun_app$cu (comp$y ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v4 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (fun_app$am (fun_app$ba (map_prod$a ?v0) ?v1) (fun_app$ay (fun_app$bz (map_prod$b ?v2) ?v3) ?v4)) (fun_app$am (fun_app$ba (map_prod$a (fun_app$cv (comp$z ?v0) ?v2)) (fun_app$cv (comp$z ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_a_prod$)) (= (fun_app$cf (map_prod$g ?v0 ?v1) (fun_app$cg (map_prod$h ?v2 ?v3) ?v4)) (fun_app$cf (map_prod$g (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_b_tree_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v4 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (fun_app$cm (map_prod$j ?v0 ?v1) (fun_app$az (map_prod$ ?v2 ?v3) ?v4)) (fun_app$az (map_prod$ (fun_app$t (comp$a ?v0) ?v2) (fun_app$cr (comp$v ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_fun$) (?v4 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (fun_app$ax (fun_app$cs (map_prod$k ?v0) ?v1) (fun_app$am (fun_app$ba (map_prod$a ?v2) ?v3) ?v4)) (fun_app$am (fun_app$ba (map_prod$a (fun_app$ct (comp$w ?v0) ?v2)) (fun_app$ct (comp$w ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) (?v4 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (fun_app$az (map_prod$ ?v0 ?v1) (fun_app$cd (map_prod$e ?v2 ?v3) ?v4)) (fun_app$az (map_prod$ (fun_app$t (comp$a ?v0) ?v2) (fun_app$cu (comp$y ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v4 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (fun_app$am (fun_app$ba (map_prod$a ?v0) ?v1) (fun_app$ay (fun_app$bz (map_prod$b ?v2) ?v3) ?v4)) (fun_app$am (fun_app$ba (map_prod$a (fun_app$cv (comp$z ?v0) ?v2)) (fun_app$cv (comp$z ?v1) ?v3)) ?v4)) )) +(assert (= (map_prod$f id$ id$) id$o)) +(assert (= (map_prod$l id$ id$a) id$q)) +(assert (= (map_prod$m id$a id$) id$r)) +(assert (= (fun_app$cs (map_prod$k id$a) id$a) id$s)) +(assert (forall ((?v0 B_b_prod$)) (= (fun_app$ce (map_prod$f id$ id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_tree_prod$)) (= (fun_app$cw (map_prod$l id$ id$a) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_prod$)) (= (fun_app$cx (map_prod$m id$a id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_tree_prod$)) (= (fun_app$ax (fun_app$cs (map_prod$k id$a) id$a) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 A_b_fun$)) (! (= (fun_app$w (fun_app$bb (case_sum$ ?v0) ?v1) (inr$ ?v2)) (fun_app$c ?v1 ?v2)) :pattern ((fun_app$w (fun_app$bb (case_sum$ ?v0) ?v1) (inr$ ?v2)))))) +(assert (forall ((?v0 B$) (?v1 B_tree$) (?v2 B_tree$)) (! (= (node$ ?v0 ?v1 ?v2) (ctor_tree$ (id_bnf$a (pair$a ?v0 (pair$ ?v1 ?v2))))) :pattern ((node$ ?v0 ?v1 ?v2))))) +(assert (forall ((?v0 A$) (?v1 A_tree$) (?v2 A_tree$)) (! (= (node$a ?v0 ?v1 ?v2) (ctor_tree$a (id_bnf$b (pair$e ?v0 (pair$d ?v1 ?v2))))) :pattern ((node$a ?v0 ?v1 ?v2))))) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$)) (= (fun_app$cy (comp$aa (fun_app$bb (case_sum$ ?v0) ?v1)) uun$) ?v1) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_a_fun$)) (= (comp$j ?v0 (fun_app$cl (case_sum$e ?v1) ?v2)) (case_sum$d (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v0) ?v2))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 A_b_fun_b_tree_fun$)) (= (fun_app$ct (comp$w ?v0) (fun_app$bb (case_sum$ ?v1) ?v2)) (fun_app$bb (case_sum$ (fun_app$s (comp$ ?v0) ?v1)) (fun_app$ah (comp$ab ?v0) ?v2))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_bool_fun$) (?v3 A_a_tree_fun$) (?v4 A_a_fun$) (?v5 A_bool_fun$) (?v6 A_a_tree_fun$) (?v7 A_a_fun$)) (= (comp$ac (map_tree$ ?v0) (fun_app$cz (fun_app$da (fun_app$db (fun_app$dc (fun_app$dd (fun_app$de (corec_tree$ ?v1) ?v2) ?v3) ?v4) ?v5) ?v6) ?v7)) (corec_tree$a (fun_app$v (comp$b ?v0) ?v1) ?v2 (comp$ac (map_tree$ ?v0) ?v3) ?v4 ?v5 (comp$ac (map_tree$ ?v0) ?v6) ?v7)) )) +(assert (forall ((?v0 B_tree_bool_fun$) (?v1 A_b_fun_bool_fun$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_bool_fun$) (?v4 B_tree_b_tree_fun$) (?v5 A_b_fun_b_tree_fun$)) (=> (and (fun_app$ad (fun_app$df (case_sum$f ?v0) ?v1) ?v2) (and (forall ((?v6 B_tree$)) (=> (fun_app$dg ?v0 ?v6) (fun_app$dg ?v3 (fun_app$x ?v4 ?v6))) ) (forall ((?v6 A_b_fun$)) (=> (fun_app$au ?v1 ?v6) (fun_app$dg ?v3 (fun_app$c ?v5 ?v6))) ))) (fun_app$dg ?v3 (fun_app$w (fun_app$bb (case_sum$ ?v4) ?v5) ?v2))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_b_fun$)) (= (fun_app$x (map_tree$a ?v0) (fun_app$c (fun_app$dh (fun_app$di (unfold_tree$ (uuo$ ?v1)) (uup$ ?v2)) (uup$ ?v3)) ?v4)) (fun_app$c (fun_app$dh (fun_app$di (unfold_tree$ (uuo$ ?v1)) (uup$ ?v2)) (uup$ ?v3)) (fun_app$u (comp$c ?v0) ?v4))) )) +(assert (forall ((?v0 A_b_fun_b_fun$) (?v1 A_b_fun_bool_fun$) (?v2 A_b_fun_b_tree_fun$) (?v3 A_b_fun_a_b_fun_fun$) (?v4 A_b_fun_bool_fun$) (?v5 A_b_fun_b_tree_fun$) (?v6 A_b_fun_a_b_fun_fun$)) (= (fun_app$dh (fun_app$dj (fun_app$dk (fun_app$dl (fun_app$dm (fun_app$dn (corec_tree$b ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) ?v6) (dtor_corec_tree$ (fun_app$ao (fun_app$ap (fun_app$aq (fun_app$ar (fun_app$as (fun_app$at (uuq$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) ?v6))) )) +(assert (forall ((?v0 B_tree$) (?v1 A_b_fun$)) (= (= (inl$ ?v0) (inr$ ?v1)) false) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_tree$)) (= (= (inr$ ?v0) (inl$ ?v1)) false) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$)) (= (fun_app$do (comp$ad (fun_app$bb (case_sum$ ?v0) ?v1)) uur$) ?v0) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_bool_fun$)) (= (exists ((?v1 B_tree_a_b_fun_sum$)) (fun_app$ad ?v0 ?v1) ) (or (exists ((?v1 B_tree$)) (fun_app$ad ?v0 (inl$ ?v1)) ) (exists ((?v1 A_b_fun$)) (fun_app$ad ?v0 (inr$ ?v1)) ))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_bool_fun$)) (= (forall ((?v1 B_tree_a_b_fun_sum$)) (fun_app$ad ?v0 ?v1) ) (and (forall ((?v1 B_tree$)) (fun_app$ad ?v0 (inl$ ?v1)) ) (forall ((?v1 A_b_fun$)) (fun_app$ad ?v0 (inr$ ?v1)) ))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (=> (and (forall ((?v1 B_tree$)) (=> (= ?v0 (inl$ ?v1)) false) ) (forall ((?v1 A_b_fun$)) (=> (= ?v0 (inr$ ?v1)) false) )) false) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (=> (and (forall ((?v1 B_tree$)) (=> (= ?v0 (inl$ ?v1)) false) ) (forall ((?v1 A_b_fun$)) (=> (= ?v0 (inr$ ?v1)) false) )) false) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_tree$)) (not (= (inr$ ?v0) (inl$ ?v1))) )) +(assert (forall ((?v0 B_tree$) (?v1 A_b_fun$)) (not (= (inl$ ?v0) (inr$ ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_tree$)) (not (= (inr$ ?v0) (inl$ ?v1))) )) +(assert (forall ((?v0 B_tree$) (?v1 A_b_fun$)) (not (= (inl$ ?v0) (inr$ ?v1))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 B_tree$)) (! (= (fun_app$w (fun_app$bb (case_sum$ ?v0) ?v1) (inl$ ?v2)) (fun_app$x ?v0 ?v2)) :pattern ((fun_app$w (fun_app$bb (case_sum$ ?v0) ?v1) (inl$ ?v2)))))) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 Bool) (?v3 B_tree$) (?v4 A_b_fun$)) (= (fun_app$w (fun_app$bb (case_sum$ ?v0) ?v1) (ite ?v2 (inl$ ?v3) (inr$ ?v4))) (ite ?v2 (fun_app$x ?v0 ?v3) (fun_app$c ?v1 ?v4))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$)) (= (fun_app$bb (case_sum$ (uus$ ?v0)) (uut$ ?v0)) ?v0) )) +(assert (forall ((?v0 B_tree$)) (= (ctor_tree$ (fun_app$bc dtor_tree$ ?v0)) ?v0) )) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (= (fun_app$bc dtor_tree$ (ctor_tree$ ?v0)) ?v0) )) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_b_fun$) (?v5 A_b_fun$)) (=> (and (= (fun_app$bh (comp$e ?v0) ?v1) (fun_app$bh (comp$e ?v2) ?v3)) (= (fun_app$v (comp$b ?v4) ?v2) ?v5)) (= (fun_app$v (comp$b (fun_app$v (comp$b ?v4) ?v0)) ?v1) (fun_app$v (comp$b ?v5) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$) (?v4 B_b_fun$) (?v5 A_b_fun$)) (=> (and (= (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (= (fun_app$u (comp$c ?v4) ?v2) ?v5)) (= (fun_app$v (comp$b (fun_app$u (comp$c ?v4) ?v0)) ?v1) (fun_app$v (comp$b ?v5) ?v3))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$) (?v4 A_a_fun$) (?v5 A_a_fun$)) (=> (and (= (fun_app$u (comp$c ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (= (fun_app$bh (comp$e ?v3) ?v4) ?v5)) (= (fun_app$u (comp$c ?v0) (fun_app$v (comp$b ?v1) ?v4)) (fun_app$v (comp$b ?v2) ?v5))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 B_b_fun$) (?v3 A_b_fun$) (?v4 A_a_fun$) (?v5 A_b_fun$)) (=> (and (= (fun_app$v (comp$b ?v0) ?v1) (fun_app$u (comp$c ?v2) ?v3)) (= (fun_app$v (comp$b ?v3) ?v4) ?v5)) (= (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e ?v1) ?v4)) (fun_app$u (comp$c ?v2) ?v5))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$) (?v4 A_a_fun$) (?v5 A_a_fun$)) (=> (and (= (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (= (fun_app$bh (comp$e ?v3) ?v4) ?v5)) (= (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e ?v1) ?v4)) (fun_app$v (comp$b ?v2) ?v5))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A_a_fun$) (?v3 A_b_fun$)) (=> (= (fun_app$bh (comp$e ?v0) ?v1) ?v2) (= (fun_app$v (comp$b (fun_app$v (comp$b ?v3) ?v0)) ?v1) (fun_app$v (comp$b ?v3) ?v2))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 B_b_fun$)) (=> (= (fun_app$v (comp$b ?v0) ?v1) ?v2) (= (fun_app$v (comp$b (fun_app$u (comp$c ?v3) ?v0)) ?v1) (fun_app$u (comp$c ?v3) ?v2))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$)) (=> (= (fun_app$u (comp$c ?v0) ?v1) ?v2) (= (fun_app$u (comp$c ?v0) (fun_app$v (comp$b ?v1) ?v3)) (fun_app$v (comp$b ?v2) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$)) (=> (= (fun_app$v (comp$b ?v0) ?v1) ?v2) (= (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e ?v1) ?v3)) (fun_app$v (comp$b ?v2) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A$) (?v3 A_b_fun$) (?v4 A_a_fun$)) (=> (= (fun_app$ac ?v0 (fun_app$aw ?v1 ?v2)) (fun_app$ac ?v3 (fun_app$aw ?v4 ?v2))) (= (fun_app$ac (fun_app$v (comp$b ?v0) ?v1) ?v2) (fun_app$ac (fun_app$v (comp$b ?v3) ?v4) ?v2))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A$)) (= (fun_app$d (map_tree$ ?v0) (fun_app$dp (fun_app$cz (fun_app$dq (unfold_tree$a ?v1) ?v2) ?v3) ?v4)) (unfold_tree$b (fun_app$v (comp$b ?v0) ?v1) ?v2 ?v3 ?v4)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 A_b_fun_b_tree_fun$)) (=> (= (fun_app$do (comp$ad ?v0) uur$) ?v1) (= (= ?v2 (fun_app$cy (comp$aa ?v0) uun$)) (= (fun_app$bb (case_sum$ ?v1) ?v2) ?v0))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree_a_b_fun_sum$)) (=> (= (fun_app$do (comp$ad ?v0) uur$) ?v1) (= (fun_app$w ?v0 ?v2) (fun_app$w (fun_app$bb (case_sum$ ?v1) (fun_app$cy (comp$aa ?v0) uun$)) ?v2))) )) +(assert (forall ((?v0 A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$) (?v1 A_b_fun$)) (= (fun_app$bc dtor_tree$ (fun_app$c (dtor_corec_tree$ ?v0) ?v1)) (fun_app$az (map_pre_tree$ id$ (fun_app$bb (case_sum$ id$a) (dtor_corec_tree$ ?v0))) (fun_app$an ?v0 ?v1))) )) +(assert (forall ((?v0 A_b_fun_b_tree_fun$) (?v1 A_b_fun_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$)) (=> (= (comp$ae (map_pre_tree$ id$ (fun_app$bb (case_sum$ id$a) ?v0)) ?v1) (comp$af dtor_tree$ ?v0)) (= ?v0 (dtor_corec_tree$ ?v1))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (=> (and (forall ((?v1 B_tree$)) (=> (= ?v0 (inl$ ?v1)) false) ) (forall ((?v1 A_b_fun$)) (=> (= ?v0 (inr$ ?v1)) false) )) false) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B$)) (= (swap$ (pair$h ?v0 ?v1)) (pair$c ?v1 ?v0)) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (swap$a (pair$c ?v0 ?v1)) (pair$h ?v1 ?v0)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$)) (= (swap$b (pair$b ?v0 ?v1)) (pair$b ?v1 ?v0)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$) (?v2 A_b_fun$) (?v3 A_a_fun$)) (= (map_pre_tree$a (fun_app$v (comp$b ?v0) ?v1) (fun_app$v (comp$b ?v2) ?v3)) (comp$ag (map_pre_tree$a ?v0 ?v2) (map_pre_tree$b ?v1 ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_a_a_prod_prod$)) (= (fun_app$dr (map_pre_tree$a ?v0 ?v1) (fun_app$ds (map_pre_tree$b ?v2 ?v3) ?v4)) (fun_app$dr (map_pre_tree$a (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3)) ?v4)) )) +(assert (= (map_pre_tree$c id$ id$) id$t)) +(assert (= (map_pre_tree$d id$ id$a) id$m)) +(assert (= (map_pre_tree$e id$a id$) id$u)) +(assert (= (map_pre_tree$f id$a id$a) id$v)) +(assert (forall ((?v0 B_b_b_prod_prod$)) (= (fun_app$dt (map_pre_tree$c id$ id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (= (fun_app$cm (map_pre_tree$d id$ id$a) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_b_prod_prod$)) (= (fun_app$du (map_pre_tree$e id$a id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_tree_b_tree_prod_prod$)) (= (fun_app$dv (map_pre_tree$f id$a id$a) ?v0) ?v0) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$)) (=> (not (= ?v0 ?v1)) (not (= (inr$ ?v0) (inr$ ?v1)))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_a_b_b_prod_prod_fun$)) (= (fun_app$dw (comp$ah (map_tree$ ?v0)) (dtor_unfold_tree$ ?v1)) (dtor_unfold_tree$a (comp$ai (map_pre_tree$g ?v0 id$) ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_tree_a_b_tree_b_tree_prod_prod_fun$)) (= (fun_app$bt (comp$q (map_tree$ ?v0)) (dtor_unfold_tree$b ?v1)) (dtor_unfold_tree$c (comp$aj (map_pre_tree$h ?v0 id$a) ?v1))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 B_a_b_b_prod_prod_fun$)) (= (comp$ak (map_tree$c ?v0) (dtor_unfold_tree$ ?v1)) (dtor_unfold_tree$ (fun_app$dx (comp$al (map_pre_tree$i ?v0 id$)) ?v1))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 B_tree_a_b_tree_b_tree_prod_prod_fun$)) (= (comp$o (map_tree$c ?v0) (dtor_unfold_tree$b ?v1)) (dtor_unfold_tree$b (fun_app$dy (comp$am (map_pre_tree$j ?v0 id$a)) ?v1))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B$)) (= (fun_app$dz (fun_app$ea (tree_recurse$ ?v0) ?v1) ?v2) (unfold_tree$c (uuu$ ?v2) (uuv$ ?v0) (uuv$ ?v1) id$)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree$)) (= (tree_recurse$a ?v0 ?v1 ?v2) (unfold_tree$d (uuw$ ?v2) (uux$ ?v0) (uux$ ?v1) id$a)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B$)) (= (comp$an (map_prod$f ?v0 id$) (convol$ id$ ?v1) ?v2) (fun_app$b (convol$ (fun_app$t (comp$a id$) ?v0) ?v1) ?v2)) )) +(assert (forall ((?v0 B_b_tree_fun$) (?v1 B_b_fun$) (?v2 B$)) (= (comp$ao (map_prod$n ?v0 id$) (convol$ id$ ?v1) ?v2) (convol$a (fun_app$eb (comp$ap id$a) ?v0) ?v1 ?v2)) )) +(assert (forall ((?v0 B_tree_b_fun$) (?v1 B_tree_b_fun$) (?v2 B_tree$)) (= (comp$aq (map_prod$o ?v0 id$) (convol$b id$a ?v1) ?v2) (convol$c (fun_app$ec (comp$ar id$) ?v0) ?v1 ?v2)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_fun$) (?v2 B_tree$)) (= (comp$as (map_prod$m ?v0 id$) (convol$b id$a ?v1) ?v2) (fun_app$ed (convol$b (fun_app$s (comp$ id$a) ?v0) ?v1) ?v2)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_tree_fun$) (?v2 B$)) (= (comp$at (map_prod$l ?v0 id$a) (convol$d id$ ?v1) ?v2) (fun_app$ee (convol$d (fun_app$t (comp$a id$) ?v0) ?v1) ?v2)) )) +(assert (forall ((?v0 B_b_tree_fun$) (?v1 B_b_tree_fun$) (?v2 B$)) (= (comp$au (map_prod$p ?v0 id$a) (convol$d id$ ?v1) ?v2) (convol$e (fun_app$eb (comp$ap id$a) ?v0) ?v1 ?v2)) )) +(assert (forall ((?v0 B_tree_b_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree$)) (= (comp$av (map_prod$q ?v0 id$a) (convol$f id$a ?v1) ?v2) (convol$g (fun_app$ec (comp$ar id$) ?v0) ?v1 ?v2)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree$)) (= (comp$aw (fun_app$cs (map_prod$k ?v0) id$a) (convol$f id$a ?v1) ?v2) (fun_app$ (convol$f (fun_app$s (comp$ id$a) ?v0) ?v1) ?v2)) )) +(assert (forall ((?v0 A_a_fun$) (?v1 A_tree$)) (= (fun_app$bd dtor_tree$a (fun_app$bf (map_tree$c ?v0) ?v1)) (fun_app$ef (map_pre_tree$k ?v0 (map_tree$c ?v0)) (fun_app$bd dtor_tree$a ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_tree$)) (= (fun_app$bc dtor_tree$ (fun_app$d (map_tree$ ?v0) ?v1)) (fun_app$eg (map_pre_tree$l ?v0 (map_tree$ ?v0)) (fun_app$bd dtor_tree$a ?v1))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree$)) (= (fun_app$bc dtor_tree$ (fun_app$x (map_tree$a ?v0) ?v1)) (fun_app$cm (map_pre_tree$d ?v0 (map_tree$a ?v0)) (fun_app$bc dtor_tree$ ?v1))) )) +(assert (forall ((?v0 A_tree_a_tree_fun$) (?v1 A_a_fun$)) (=> (= (comp$ax dtor_tree$a ?v0) (comp$ay (map_pre_tree$k ?v1 ?v0) dtor_tree$a)) (= ?v0 (map_tree$c ?v1))) )) +(assert (forall ((?v0 A_tree_b_tree_fun$) (?v1 A_b_fun$)) (=> (= (comp$az dtor_tree$ ?v0) (comp$ba (map_pre_tree$l ?v1 ?v0) dtor_tree$a)) (= ?v0 (map_tree$ ?v1))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_b_fun$)) (=> (= (comp$bb dtor_tree$ ?v0) (comp$bc (map_pre_tree$d ?v1 ?v0) dtor_tree$)) (= ?v0 (map_tree$a ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$)) (= (fun_app$bm (comp$i (fun_app$eh (convol$h ?v0) ?v1)) ?v2) (fun_app$eh (convol$h (fun_app$v (comp$b ?v0) ?v2)) (fun_app$v (comp$b ?v1) ?v2))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A$)) (! (= (fun_app$dp (fun_app$cz (tree_recurse$b ?v0) ?v1) ?v2) (node$a ?v2 (fun_app$bf (map_tree$c ?v0) (fun_app$dp (fun_app$cz (tree_recurse$b ?v0) ?v1) ?v2)) (fun_app$bf (map_tree$c ?v1) (fun_app$dp (fun_app$cz (tree_recurse$b ?v0) ?v1) ?v2)))) :pattern ((fun_app$dp (fun_app$cz (tree_recurse$b ?v0) ?v1) ?v2))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$)) (= (fun_app$ei (comp$bd (map_prod$g ?v0 ?v1)) (convol$i ?v2 ?v3)) (fun_app$eh (convol$h (fun_app$v (comp$b ?v0) ?v2)) (fun_app$v (comp$b ?v1) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$)) (= (fun_app$dw (comp$ah (map_tree$ ?v0)) (dtor_corec_tree$a ?v1)) (dtor_corec_tree$b (comp$be (map_pre_tree$m ?v0 (map_sum$ (map_tree$ ?v0) id$)) ?v1))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$)) (= (fun_app$bt (comp$q (map_tree$ ?v0)) (dtor_corec_tree$c ?v1)) (dtor_corec_tree$d (comp$bf (map_pre_tree$n ?v0 (map_sum$a (map_tree$ ?v0) id$a)) ?v1))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 B_a_a_tree_b_sum_a_tree_b_sum_prod_prod_fun$)) (= (comp$ak (map_tree$c ?v0) (dtor_corec_tree$a ?v1)) (dtor_corec_tree$a (fun_app$ej (comp$bg (map_pre_tree$o ?v0 (map_sum$b (map_tree$c ?v0) id$))) ?v1))) )) +(assert (forall ((?v0 A_a_fun$) (?v1 B_tree_a_a_tree_b_tree_sum_a_tree_b_tree_sum_prod_prod_fun$)) (= (comp$o (map_tree$c ?v0) (dtor_corec_tree$c ?v1)) (dtor_corec_tree$c (fun_app$ek (comp$bh (map_pre_tree$p ?v0 (map_sum$c (map_tree$c ?v0) id$a))) ?v1))) )) +(assert (forall ((?v0 B$) (?v1 A_a_fun$) (?v2 A$)) (= (fun_app$ac (fun_app$v (comp$b (uue$ ?v0)) ?v1) ?v2) ?v0) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$)) (= (= (uuy$ ?v0) (uuy$ ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$)) (= (= (uuz$ ?v0) (uuz$ ?v1)) (= ?v0 ?v1)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$)) (= (comp$bi (map_sum$d ?v0 ?v1) (map_sum$e ?v2 ?v3)) (map_sum$d (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_a_sum$)) (= (fun_app$el (map_sum$d ?v0 ?v1) (fun_app$em (map_sum$e ?v2 ?v3) ?v4)) (fun_app$el (map_sum$d (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_a_sum$)) (= (fun_app$el (map_sum$d ?v0 ?v1) (fun_app$em (map_sum$e ?v2 ?v3) ?v4)) (fun_app$el (map_sum$d (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3)) ?v4)) )) +(assert (= (map_sum$f id$ id$) id$b)) +(assert (= (map_sum$g id$ id$a) id$w)) +(assert (= (map_sum$h id$a id$) id$x)) +(assert (= (map_sum$i id$a id$a) id$y)) +(assert (forall ((?v0 B_b_sum$)) (= (fun_app$cn (map_sum$f id$ id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_b_tree_sum$)) (= (fun_app$en (map_sum$g id$ id$a) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_sum$)) (= (fun_app$eo (map_sum$h id$a id$) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_tree_sum$)) (= (fun_app$ep (map_sum$i id$a id$a) ?v0) ?v0) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_a_b_fun_fun$) (?v2 Bool) (?v3 A_b_fun$) (?v4 B_tree_a_b_fun_sum$)) (= (fun_app$ca (fun_app$eq (map_sum$j ?v0) ?v1) (ite ?v2 (inr$ ?v3) ?v4)) (ite ?v2 (inr$ (fun_app$u ?v1 ?v3)) (fun_app$ca (fun_app$eq (map_sum$j ?v0) ?v1) ?v4))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_a_b_fun_fun$) (?v2 Bool) (?v3 B_tree_a_b_fun_sum$) (?v4 A_b_fun$)) (= (fun_app$ca (fun_app$eq (map_sum$j ?v0) ?v1) (ite ?v2 ?v3 (inr$ ?v4))) (ite ?v2 (fun_app$ca (fun_app$eq (map_sum$j ?v0) ?v1) ?v3) (inr$ (fun_app$u ?v1 ?v4)))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_a_b_fun_fun$)) (= (comp$bj (fun_app$eq (map_sum$j ?v0) ?v1) uun$) (comp$bk uun$ ?v1)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_a_b_fun_fun$) (?v2 A_b_fun$)) (! (= (fun_app$ca (fun_app$eq (map_sum$j ?v0) ?v1) (inr$ ?v2)) (inr$ (fun_app$u ?v1 ?v2))) :pattern ((fun_app$ca (fun_app$eq (map_sum$j ?v0) ?v1) (inr$ ?v2)))))) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$)) (= (comp$bl (case_sum$d ?v0 ?v1) (map_sum$e ?v2 ?v3)) (case_sum$d (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3))) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 B_tree_b_tree_fun$) (?v3 A_b_fun_a_b_fun_fun$)) (= (fun_app$cv (comp$z (fun_app$bb (case_sum$ ?v0) ?v1)) (fun_app$eq (map_sum$j ?v2) ?v3)) (fun_app$bb (case_sum$ (fun_app$s (comp$ ?v0) ?v2)) (fun_app$dh (comp$bm ?v1) ?v3))) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_b_fun$) (?v2 A_a_fun$) (?v3 A_a_fun$) (?v4 A_a_sum$)) (= (fun_app$cj (case_sum$d ?v0 ?v1) (fun_app$em (map_sum$e ?v2 ?v3) ?v4)) (fun_app$cj (case_sum$d (fun_app$v (comp$b ?v0) ?v2) (fun_app$v (comp$b ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 B_tree_b_tree_fun$) (?v3 A_b_fun_a_b_fun_fun$) (?v4 B_tree_a_b_fun_sum$)) (= (fun_app$w (fun_app$bb (case_sum$ ?v0) ?v1) (fun_app$ca (fun_app$eq (map_sum$j ?v2) ?v3) ?v4)) (fun_app$w (fun_app$bb (case_sum$ (fun_app$s (comp$ ?v0) ?v2)) (fun_app$dh (comp$bm ?v1) ?v3)) ?v4)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_b_fun$) (?v2 B_b_sum$)) (= (comp$bn (case_sum$a id$ ?v0) (map_sum$f ?v1 id$) ?v2) (fun_app$ci (case_sum$a (fun_app$t (comp$a ?v1) id$) ?v0) ?v2)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 A_b_fun$) (?v2 A_b_sum$)) (= (comp$bo (case_sum$a id$ ?v0) (map_sum$k ?v1 id$) ?v2) (case_sum$c (fun_app$v (comp$b ?v1) id$f) ?v0 ?v2)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_b_fun$) (?v2 B_tree_b_sum$)) (= (comp$bp (case_sum$a id$ ?v0) (map_sum$l ?v1 id$) ?v2) (case_sum$g (fun_app$er (comp$bq ?v1) id$a) ?v0 ?v2)) )) +(assert (forall ((?v0 B_tree_b_fun$) (?v1 B_b_fun$) (?v2 B_b_tree_sum$)) (= (comp$br (case_sum$h id$ ?v0) (map_sum$g ?v1 id$a) ?v2) (fun_app$es (case_sum$h (fun_app$t (comp$a ?v1) id$) ?v0) ?v2)) )) +(assert (forall ((?v0 B_b_tree_fun$) (?v1 B_b_tree_fun$) (?v2 B_b_sum$)) (= (comp$bs (case_sum$i id$a ?v0) (map_sum$m ?v1 id$) ?v2) (case_sum$j (fun_app$ea (comp$bt ?v1) id$) ?v0 ?v2)) )) +(assert (forall ((?v0 B_tree_b_fun$) (?v1 A_b_fun$) (?v2 A_b_tree_sum$)) (= (comp$bu (case_sum$h id$ ?v0) (map_sum$n ?v1 id$a) ?v2) (case_sum$b (fun_app$v (comp$b ?v1) id$f) ?v0 ?v2)) )) +(assert (forall ((?v0 B_tree_b_fun$) (?v1 B_tree_b_fun$) (?v2 B_tree_b_tree_sum$)) (= (comp$bv (case_sum$h id$ ?v0) (map_sum$o ?v1 id$a) ?v2) (case_sum$k (fun_app$er (comp$bq ?v1) id$a) ?v0 ?v2)) )) +(assert (forall ((?v0 B_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree_b_sum$)) (= (comp$bw (case_sum$i id$a ?v0) (map_sum$h ?v1 id$) ?v2) (fun_app$et (case_sum$i (fun_app$s (comp$ ?v1) id$a) ?v0) ?v2)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_b_tree_fun$) (?v2 B_b_tree_sum$)) (= (comp$bx (case_sum$l id$a ?v0) (map_sum$p ?v1 id$a) ?v2) (case_sum$m (fun_app$ea (comp$bt ?v1) id$) ?v0 ?v2)) )) +(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree_b_tree_sum$)) (= (comp$by (case_sum$l id$a ?v0) (map_sum$i ?v1 id$a) ?v2) (fun_app$eu (case_sum$l (fun_app$s (comp$ ?v1) id$a) ?v0) ?v2)) )) +(assert (forall ((?v0 A_bool_fun$) (?v1 A$) (?v2 A_tree$) (?v3 A_tree$)) (! (= (pred_tree$ ?v0 (node$a ?v1 ?v2 ?v3)) (and (fun_app$ev ?v0 ?v1) (and (pred_tree$ ?v0 ?v2) (pred_tree$ ?v0 ?v3)))) :pattern ((pred_tree$ ?v0 (node$a ?v1 ?v2 ?v3)))))) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (! (= (id_bnf$a ?v0) ?v0) :pattern ((id_bnf$a ?v0))))) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (! (= (id_bnf$ ?v0) ?v0) :pattern ((id_bnf$ ?v0))))) +(assert (forall ((?v0 B_b_fun$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (apfst$ ?v0 (pair$c ?v1 ?v2)) (pair$c (fun_app$aa ?v0 ?v1) ?v2)) :pattern ((apfst$ ?v0 (pair$c ?v1 ?v2)))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (! (= (fun_app$ay (apfst$a ?v0) (pair$b ?v1 ?v2)) (pair$b (fun_app$ca ?v0 ?v1) ?v2)) :pattern ((fun_app$ay (apfst$a ?v0) (pair$b ?v1 ?v2)))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (apsnd$ ?v0 (pair$c ?v1 ?v2)) (pair$c ?v1 (fun_app$ay ?v0 ?v2))) :pattern ((apsnd$ ?v0 (pair$c ?v1 ?v2)))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_fun$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (! (= (fun_app$ay (apsnd$a ?v0) (pair$b ?v1 ?v2)) (pair$b ?v1 (fun_app$ca ?v0 ?v2))) :pattern ((fun_app$ay (apsnd$a ?v0) (pair$b ?v1 ?v2)))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$)) (! (= (apsnd$b ?v0) (map_prod$ id$ ?v0)) :pattern ((apsnd$b ?v0))))) +(assert (forall ((?v0 A_a_fun$) (?v1 A_a_fun$) (?v2 A$) (?v3 A_a_fun$) (?v4 A_a_fun$) (?v5 A_b_fun$)) (=> (= (fun_app$aw ?v0 (fun_app$aw ?v1 ?v2)) (fun_app$aw ?v3 (fun_app$aw ?v4 ?v2))) (= (fun_app$ac (fun_app$v (comp$b (fun_app$v (comp$b ?v5) ?v0)) ?v1) ?v2) (fun_app$ac (fun_app$v (comp$b (fun_app$v (comp$b ?v5) ?v3)) ?v4) ?v2))) )) +(assert (forall ((?v0 B_b_tree_b_tree_prod_prod$)) (! (= (id_bnf$a ?v0) ?v0) :pattern ((id_bnf$a ?v0))))) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (! (= (id_bnf$ ?v0) ?v0) :pattern ((id_bnf$ ?v0))))) +(assert (forall ((?v0 B$) (?v1 B_b_fun$) (?v2 B$)) (=> (= ?v0 (fun_app$aa ?v1 ?v2)) (fun_app$ew (fun_app$ex (fun_app$ey (fun_app$ez (fun_app$fa (iso_tuple_update_accessor_eq_assist$ id$d) id$) ?v2) ?v1) ?v0) ?v2)) )) +(assert (forall ((?v0 B_tree$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree$)) (=> (= ?v0 (fun_app$x ?v1 ?v2)) (fun_app$dg (fun_app$fb (fun_app$fc (fun_app$fd (fun_app$fe (iso_tuple_update_accessor_eq_assist$a id$c) id$a) ?v2) ?v1) ?v0) ?v2)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (fst$a (fun_app$az (map_prod$ ?v0 ?v1) ?v2)) (fun_app$aa ?v0 (fst$c ?v2))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (fst$ (fun_app$am (fun_app$ba (map_prod$a ?v0) ?v1) ?v2)) (fun_app$w ?v0 (fst$b ?v2))) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$) (?v2 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (snd$a (fun_app$az (map_prod$ ?v0 ?v1) ?v2)) (fun_app$am ?v1 (snd$c ?v2))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (snd$ (fun_app$am (fun_app$ba (map_prod$a ?v0) ?v1) ?v2)) (fun_app$w ?v1 (snd$b ?v2))) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (pair$c (fst$c ?v0) (snd$c ?v0)) ?v0) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (pair$b (fst$b ?v0) (snd$b ?v0)) ?v0) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$)) (= (comp$bz uva$ (map_prod$ ?v0 ?v1)) (comp$ca ?v0 uvb$)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$)) (= (comp$cb uvc$ (fun_app$ba (map_prod$a ?v0) ?v1)) (comp$cc ?v0 uvd$)) )) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$)) (= (comp$cd uve$ (map_prod$ ?v0 ?v1)) (comp$ce ?v1 uvf$)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$)) (= (comp$cb uvg$ (fun_app$ba (map_prod$a ?v0) ?v1)) (comp$cc ?v1 uvh$)) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= ?v0 (pair$c (fst$c ?v0) (snd$c ?v0))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= ?v0 (pair$b (fst$b ?v0) (snd$b ?v0))) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (=> (=> (= ?v0 (pair$c (fst$c ?v0) (snd$c ?v0))) false) false) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (=> (= ?v0 (pair$b (fst$b ?v0) (snd$b ?v0))) false) false) )) +(assert (forall ((?v0 B_bool_fun$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (and (fun_app$ew ?v0 ?v1) (fun_app$af ?v2 ?v3)) (and (fun_app$ew ?v0 (fst$c (pair$c ?v1 ?v3))) (fun_app$af ?v2 (snd$c (pair$c ?v1 ?v3))))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_bool_fun$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum_bool_fun$) (?v3 B_tree_a_b_fun_sum$)) (=> (and (fun_app$ad ?v0 ?v1) (fun_app$ad ?v2 ?v3)) (and (fun_app$ad ?v0 (fst$b (pair$b ?v1 ?v3))) (fun_app$ad ?v2 (snd$b (pair$b ?v1 ?v3))))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_bool_fun_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B$)) (=> (fun_app$ew (fun_app$ff ?v0 ?v1) ?v2) (fun_app$ew (fun_app$ff ?v0 (snd$c (pair$c ?v2 ?v1))) (fst$c (pair$c ?v2 ?v1)))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_bool_fun_fun$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (=> (fun_app$ad (fun_app$ae ?v0 ?v1) ?v2) (fun_app$ad (fun_app$ae ?v0 (snd$b (pair$b ?v2 ?v1))) (fst$b (pair$b ?v2 ?v1)))) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (= ?v0 (pair$c ?v1 ?v2)) (= (fst$c ?v0) ?v1)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (=> (= ?v0 (pair$b ?v1 ?v2)) (= (fst$b ?v0) ?v1)) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fst$c (pair$c ?v0 ?v1)) ?v0) :pattern ((pair$c ?v0 ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$)) (! (= (fst$b (pair$b ?v0 ?v1)) ?v0) :pattern ((pair$b ?v0 ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B$)) (=> (= (fst$c (pair$c ?v0 ?v1)) ?v2) (= ?v0 ?v2)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (=> (= (fst$b (pair$b ?v0 ?v1)) ?v2) (= ?v0 ?v2)) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (= ?v0 (pair$c ?v1 ?v2)) (= (snd$c ?v0) ?v2)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (=> (= ?v0 (pair$b ?v1 ?v2)) (= (snd$b ?v0) ?v2)) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (snd$c (pair$c ?v0 ?v1)) ?v1) :pattern ((pair$c ?v0 ?v1))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$)) (! (= (snd$b (pair$b ?v0 ?v1)) ?v1) :pattern ((pair$b ?v0 ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (= (snd$c (pair$c ?v0 ?v1)) ?v2) (= ?v1 ?v2)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (=> (= (snd$b (pair$b ?v0 ?v1)) ?v2) (= ?v1 ?v2)) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_bool_fun_fun$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v3 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (=> (and (fun_app$af (fun_app$ag ?v0 ?v1) ?v2) (= ?v3 (pair$c ?v1 ?v2))) (fun_app$af (fun_app$ag ?v0 (fst$c ?v3)) (snd$c ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_bool_fun_fun$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (and (fun_app$ad (fun_app$ae ?v0 ?v1) ?v2) (= ?v3 (pair$b ?v1 ?v2))) (fun_app$ad (fun_app$ae ?v0 (fst$b ?v3)) (snd$b ?v3))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod$)) (! (= (swap$ ?v0) (pair$c (snd$h ?v0) (fst$h ?v0))) :pattern ((swap$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (swap$b ?v0) (pair$b (snd$b ?v0) (fst$b ?v0))) :pattern ((swap$b ?v0))))) +(assert (forall ((?v0 B$)) (= (fun_app$aa (fun_app$fg (comp$cf uvi$) uvj$) ?v0) (fun_app$aa id$ ?v0)) )) +(assert (forall ((?v0 B_tree$)) (= (fun_app$x (fun_app$fh (comp$cg uvg$) uvk$) ?v0) (fun_app$x id$a ?v0)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (= (fun_app$ca (fun_app$fi (comp$ch uvh$) uvl$) ?v0) (id$z ?v0)) )) +(assert (forall ((?v0 B$)) (= (fun_app$aa (fun_app$fg (comp$cf uvm$) uvj$) ?v0) (fun_app$aa id$ ?v0)) )) +(assert (forall ((?v0 B_tree$)) (= (fun_app$x (fun_app$fh (comp$cg uvc$) uvk$) ?v0) (fun_app$x id$a ?v0)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (= (fun_app$ca (fun_app$fi (comp$ch uvd$) uvl$) ?v0) (id$z ?v0)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (= ?v0 (snd$c ?v1)) (exists ((?v2 B$)) (= ?v1 (pair$c ?v2 ?v0)) )) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (= ?v0 (snd$b ?v1)) (exists ((?v2 B_tree_a_b_fun_sum$)) (= ?v1 (pair$b ?v2 ?v0)) )) )) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (and (member$a (pair$c ?v0 ?v1) ?v2) (= ?v3 ?v1)) (member$a (pair$c ?v0 ?v3) ?v2)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v3 B_tree_a_b_fun_sum$)) (=> (and (member$ (pair$b ?v0 ?v1) ?v2) (= ?v3 ?v1)) (member$ (pair$b ?v0 ?v3) ?v2)) )) +(assert (forall ((?v0 B$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (= ?v0 (fst$c ?v1)) (exists ((?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= ?v1 (pair$c ?v0 ?v2)) )) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (= ?v0 (fst$b ?v1)) (exists ((?v2 B_tree_a_b_fun_sum$)) (= ?v1 (pair$b ?v0 ?v2)) )) )) +(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$)) (= (fun_app$v (comp$b (ctor_rec$ ?v0)) ?v1) (ctor_rec$ (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e (fun_app$bh (comp$e id_bnf$c) ?v1)) id_bnf$c)))) )) +(assert (forall ((?v0 A_b_fun$)) (= ?v0 (ctor_rec$ (fun_app$v (comp$b ?v0) id_bnf$c))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$)) (! (= (pair$b ?v0 ?v1) (xtor$ (id_bnf$d (pair$b ?v0 ?v1)))) :pattern ((pair$b ?v0 ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_tree_b_tree_prod$)) (! (= (pair$a ?v0 ?v1) (xtor$a (id_bnf$a (pair$a ?v0 ?v1)))) :pattern ((pair$a ?v0 ?v1))))) +(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (pair$c ?v0 ?v1) (xtor$b (id_bnf$ (pair$c ?v0 ?v1)))) :pattern ((pair$c ?v0 ?v1))))) +(assert (forall ((?v0 A_b_fun$)) (! (= (inr$ ?v0) (xtor$c (id_bnf$e (inr$ ?v0)))) :pattern ((inr$ ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod$)) (= (snd$h ?v0) (comp$ci uvb$ (uncurry$ uvn$) ?v0)) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (snd$b ?v0) (fun_app$f (fun_app$fj (comp$cj uvd$) (uncurry$a uvo$)) ?v0)) )) +(assert (= (uncurry$b uvp$) id$n)) +(assert (= (uncurry$a uvq$) id$aa)) +(assert (forall ((?v0 B_b_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_b_tree_prod_fun$)) (= (map_prod$ ?v0 ?v1) (uncurry$c (uvr$ ?v0 ?v1))) )) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$)) (= (fun_app$ba (map_prod$a ?v0) ?v1) (uncurry$d (uvs$ ?v0 ?v1))) )) +(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (! (= (fun_app$cd (uncurry$b uvp$) ?v0) ?v0) :pattern ((fun_app$cd (uncurry$b uvp$) ?v0))))) +(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$ay (uncurry$a uvq$) ?v0) ?v0) :pattern ((fun_app$ay (uncurry$a uvq$) ?v0))))) +(check-sat) +(exit) + |